@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/uri-launcher.d.ts

@@ -1,13 +1,51 @@
 import { Window } from "./window.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * Asynchronous API to open a uri with an application.
+ *
+ * `GtkUriLauncher` collects the arguments that are needed to open the uri.
+ *
+ * Depending on system configuration, user preferences and available APIs, this
+ * may or may not show an app chooser dialog or launch the default application
+ * right away.
+ *
+ * The operation is started with the [method@Gtk.UriLauncher.launch] function.
+ *
+ * To launch a file, use [class@Gtk.FileLauncher].
+ */
 export declare class UriLauncher extends GObject.GObject {
+    /**
+     * Creates a new `GtkUriLauncher` object.
+     * @param uri - the uri to open
+     */
     constructor(uri?: string | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Returns whether the launcher is likely to succeed
+     * in launching an application for its uri.
+     *
+     * This can be used to disable controls that trigger
+     * the launcher when they are known not to work.
+     * @param parent - the parent window
+     */
     canLaunch(parent?: Window | null): boolean;
+    /**
+     * Gets the uri that will be opened.
+     */
     getUri(): string | null;
+    /**
+     * Promise-based version of launch.
+     * Launches an application to open the uri.
+     *
+     * This may present an app chooser dialog to the user.
+     */
     launch(parent?: Window, cancellable?: Gio.Cancellable): Promise<boolean>;
+    /**
+     * Sets the uri that will be opened.
+     * @param uri - the uri
+     */
     setUri(uri?: string | null): void;
     connect(signal: "notify", handler: (self: UriLauncher, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/uri-launcher.js

@@ -1,6 +1,19 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * Asynchronous API to open a uri with an application.
+ *
+ * `GtkUriLauncher` collects the arguments that are needed to open the uri.
+ *
+ * Depending on system configuration, user preferences and available APIs, this
+ * may or may not show an app chooser dialog or launch the default application
+ * right away.
+ *
+ * The operation is started with the [method@Gtk.UriLauncher.launch] function.
+ *
+ * To launch a file, use [class@Gtk.FileLauncher].
+ */
 export class UriLauncher extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -15,6 +28,14 @@ export class UriLauncher extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Returns whether the launcher is likely to succeed
+     * in launching an application for its uri.
+     *
+     * This can be used to disable controls that trigger
+     * the launcher when they are known not to work.
+     * @param parent - the parent window
+     */
     canLaunch(parent) {
         return call("libgtk-4.so.1", "gtk_uri_launcher_can_launch", [
             {
@@ -28,6 +49,9 @@ export class UriLauncher extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the uri that will be opened.
+     */
     getUri() {
         return call("libgtk-4.so.1", "gtk_uri_launcher_get_uri", [
             {
@@ -36,6 +60,12 @@ export class UriLauncher extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Promise-based version of launch.
+     * Launches an application to open the uri.
+     *
+     * This may present an app chooser dialog to the user.
+     */
     launch(parent, cancellable) {
         return new Promise((resolve, reject) => {
             const callback = (_source, asyncResult) => {
@@ -87,6 +117,10 @@ export class UriLauncher extends GObject.GObject {
             ], { type: "undefined" });
         });
     }
+    /**
+     * Sets the uri that will be opened.
+     * @param uri - the uri
+     */
     setUri(uri) {
         call("libgtk-4.so.1", "gtk_uri_launcher_set_uri", [
             {

package/dist/generated/gtk/video.d.ts

@@ -3,24 +3,125 @@ import { MediaStream } from "./media-stream.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Shows a `GtkMediaStream` with media controls.
+ *
+ *
+ *
+ * The controls are available separately as [class@Gtk.MediaControls].
+ * If you just want to display a video without controls, you can treat it
+ * like any other paintable and for example put it into a [class@Gtk.Picture].
+ *
+ * `GtkVideo` aims to cover use cases such as previews, embedded animations,
+ * etc. It supports autoplay, looping, and simple media controls. It does
+ * not have support for video overlays, multichannel audio, device
+ * selection, or input. If you are writing a full-fledged video player,
+ * you may want to use the [iface@Gdk.Paintable] API and a media framework
+ * such as Gstreamer directly.
+ */
 export declare class Video extends Widget {
+    /**
+     * Creates a new empty `GtkVideo`.
+     */
     constructor(...args: unknown[]);
+    /**
+     * Creates a `GtkVideo` to play back the given @file.
+     * @param file - a `GFile`
+     */
     static newForFile(file?: Gio.File | null): Video;
+    /**
+     * Creates a `GtkVideo` to play back the given @filename.
+     *
+     * This is a utility function that calls [ctor@Gtk.Video.new_for_file],
+     * See that function for details.
+     * @param filename - filename to play back
+     */
     static newForFilename(filename?: string | null): Video;
+    /**
+     * Creates a `GtkVideo` to play back the given @stream.
+     * @param stream - a `GtkMediaStream`
+     */
     static newForMediaStream(stream?: MediaStream | null): Video;
+    /**
+     * Creates a `GtkVideo` to play back the resource at the
+     * given @resource_path.
+     *
+     * This is a utility function that calls [ctor@Gtk.Video.new_for_file].
+     * @param resourcePath - resource path to play back
+     */
     static newForResource(resourcePath?: string | null): Video;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns %TRUE if videos have been set to loop.
+     */
     getAutoplay(): boolean;
+    /**
+     * Gets the file played by `self` or %NULL if not playing back
+     * a file.
+     */
     getFile(): Gio.File | null;
+    /**
+     * Returns whether graphics offload is enabled.
+     *
+     * See [class@Gtk.GraphicsOffload] for more information on graphics offload.
+     */
     getGraphicsOffload(): GraphicsOffloadEnabled;
+    /**
+     * Returns %TRUE if videos have been set to loop.
+     */
     getLoop(): boolean;
+    /**
+     * Gets the media stream managed by `self` or %NULL if none.
+     */
     getMediaStream(): MediaStream | null;
+    /**
+     * Sets whether `self` automatically starts playback when it
+     * becomes visible or when a new file gets loaded.
+     * @param autoplay - whether media streams should autoplay
+     */
     setAutoplay(autoplay: boolean): void;
+    /**
+     * Makes `self` play the given @file.
+     * @param file - the file to play
+     */
     setFile(file?: Gio.File | null): void;
+    /**
+     * Makes `self` play the given @filename.
+     *
+     * This is a utility function that calls gtk_video_set_file(),
+     * @param filename - the filename to play
+     */
     setFilename(filename?: string | null): void;
+    /**
+     * Sets whether to enable graphics offload.
+     *
+     * See [class@Gtk.GraphicsOffload] for more information on graphics offload.
+     * @param enabled - the new graphics offload status
+     */
     setGraphicsOffload(enabled: GraphicsOffloadEnabled): void;
+    /**
+     * Sets whether new files loaded by `self` should be set to loop.
+     * @param loop - whether media streams should loop
+     */
     setLoop(loop: boolean): void;
+    /**
+     * Sets the media stream to be played back.
+     *
+     * `self` will take full control of managing the media stream. If you
+     * want to manage a media stream yourself, consider using a
+     * [class@Gtk.Picture] for display.
+     *
+     * If you want to display a file, consider using [method@Gtk.Video.set_file]
+     * instead.
+     * @param stream - The media stream to play or %NULL to unset
+     */
     setMediaStream(stream?: MediaStream | null): void;
+    /**
+     * Makes `self` play the resource at the given @resource_path.
+     *
+     * This is a utility function that calls [method@Gtk.Video.set_file].
+     * @param resourcePath - the resource to set
+     */
     setResource(resourcePath?: string | null): void;
     connect(signal: "notify", handler: (self: Video, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/video.js

@@ -3,10 +3,33 @@ import { getObject } from "@gtkx/ffi";
 import { MediaStream } from "./media-stream.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Shows a `GtkMediaStream` with media controls.
+ *
+ *
+ *
+ * The controls are available separately as [class@Gtk.MediaControls].
+ * If you just want to display a video without controls, you can treat it
+ * like any other paintable and for example put it into a [class@Gtk.Picture].
+ *
+ * `GtkVideo` aims to cover use cases such as previews, embedded animations,
+ * etc. It supports autoplay, looping, and simple media controls. It does
+ * not have support for video overlays, multichannel audio, device
+ * selection, or input. If you are writing a full-fledged video player,
+ * you may want to use the [iface@Gdk.Paintable] API and a media framework
+ * such as Gstreamer directly.
+ */
 export class Video extends Widget {
+    /**
+     * Creates a new empty `GtkVideo`.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a `GtkVideo` to play back the given @file.
+     * @param file - a `GFile`
+     */
     static newForFile(file) {
         const ptr = call("libgtk-4.so.1", "gtk_video_new_for_file", [
             {
@@ -17,6 +40,13 @@ export class Video extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Video);
     }
+    /**
+     * Creates a `GtkVideo` to play back the given @filename.
+     *
+     * This is a utility function that calls [ctor@Gtk.Video.new_for_file],
+     * See that function for details.
+     * @param filename - filename to play back
+     */
     static newForFilename(filename) {
         const ptr = call("libgtk-4.so.1", "gtk_video_new_for_filename", [
             {
@@ -27,6 +57,10 @@ export class Video extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Video);
     }
+    /**
+     * Creates a `GtkVideo` to play back the given @stream.
+     * @param stream - a `GtkMediaStream`
+     */
     static newForMediaStream(stream) {
         const ptr = call("libgtk-4.so.1", "gtk_video_new_for_media_stream", [
             {
@@ -37,6 +71,13 @@ export class Video extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Video);
     }
+    /**
+     * Creates a `GtkVideo` to play back the resource at the
+     * given @resource_path.
+     *
+     * This is a utility function that calls [ctor@Gtk.Video.new_for_file].
+     * @param resourcePath - resource path to play back
+     */
     static newForResource(resourcePath) {
         const ptr = call("libgtk-4.so.1", "gtk_video_new_for_resource", [
             {
@@ -53,6 +94,9 @@ export class Video extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Returns %TRUE if videos have been set to loop.
+     */
     getAutoplay() {
         return call("libgtk-4.so.1", "gtk_video_get_autoplay", [
             {
@@ -61,6 +105,10 @@ export class Video extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the file played by `self` or %NULL if not playing back
+     * a file.
+     */
     getFile() {
         const ptr = call("libgtk-4.so.1", "gtk_video_get_file", [
             {
@@ -72,6 +120,11 @@ export class Video extends Widget {
             return null;
         return getObject(ptr, Gio.File);
     }
+    /**
+     * Returns whether graphics offload is enabled.
+     *
+     * See [class@Gtk.GraphicsOffload] for more information on graphics offload.
+     */
     getGraphicsOffload() {
         return call("libgtk-4.so.1", "gtk_video_get_graphics_offload", [
             {
@@ -80,6 +133,9 @@ export class Video extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns %TRUE if videos have been set to loop.
+     */
     getLoop() {
         return call("libgtk-4.so.1", "gtk_video_get_loop", [
             {
@@ -88,6 +144,9 @@ export class Video extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the media stream managed by `self` or %NULL if none.
+     */
     getMediaStream() {
         const ptr = call("libgtk-4.so.1", "gtk_video_get_media_stream", [
             {
@@ -99,6 +158,11 @@ export class Video extends Widget {
             return null;
         return getObject(ptr, MediaStream);
     }
+    /**
+     * Sets whether `self` automatically starts playback when it
+     * becomes visible or when a new file gets loaded.
+     * @param autoplay - whether media streams should autoplay
+     */
     setAutoplay(autoplay) {
         call("libgtk-4.so.1", "gtk_video_set_autoplay", [
             {
@@ -111,6 +175,10 @@ export class Video extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Makes `self` play the given @file.
+     * @param file - the file to play
+     */
     setFile(file) {
         call("libgtk-4.so.1", "gtk_video_set_file", [
             {
@@ -124,6 +192,12 @@ export class Video extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Makes `self` play the given @filename.
+     *
+     * This is a utility function that calls gtk_video_set_file(),
+     * @param filename - the filename to play
+     */
     setFilename(filename) {
         call("libgtk-4.so.1", "gtk_video_set_filename", [
             {
@@ -137,6 +211,12 @@ export class Video extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to enable graphics offload.
+     *
+     * See [class@Gtk.GraphicsOffload] for more information on graphics offload.
+     * @param enabled - the new graphics offload status
+     */
     setGraphicsOffload(enabled) {
         call("libgtk-4.so.1", "gtk_video_set_graphics_offload", [
             {
@@ -149,6 +229,10 @@ export class Video extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether new files loaded by `self` should be set to loop.
+     * @param loop - whether media streams should loop
+     */
     setLoop(loop) {
         call("libgtk-4.so.1", "gtk_video_set_loop", [
             {
@@ -161,6 +245,17 @@ export class Video extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the media stream to be played back.
+     *
+     * `self` will take full control of managing the media stream. If you
+     * want to manage a media stream yourself, consider using a
+     * [class@Gtk.Picture] for display.
+     *
+     * If you want to display a file, consider using [method@Gtk.Video.set_file]
+     * instead.
+     * @param stream - The media stream to play or %NULL to unset
+     */
     setMediaStream(stream) {
         call("libgtk-4.so.1", "gtk_video_set_media_stream", [
             {
@@ -174,6 +269,12 @@ export class Video extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Makes `self` play the resource at the given @resource_path.
+     *
+     * This is a utility function that calls [method@Gtk.Video.set_file].
+     * @param resourcePath - the resource to set
+     */
     setResource(resourcePath) {
         call("libgtk-4.so.1", "gtk_video_set_resource", [
             {

package/dist/generated/gtk/viewport.d.ts

@@ -5,23 +5,118 @@ import { ScrollInfo } from "./scroll-info.js";
 import { Adjustment } from "./adjustment.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Implements scrollability for widgets that don't support scrolling
+ * on their own.
+ *
+ * Use `GtkViewport` to scroll child widgets such as `GtkGrid`,
+ * `GtkBox`, and so on.
+ *
+ * The `GtkViewport` will start scrolling content only if allocated
+ * less than the child widget’s minimum size in a given orientation.
+ *
+ * # CSS nodes
+ *
+ * `GtkViewport` has a single CSS node with name `viewport`.
+ *
+ * # Accessibility
+ *
+ * Until GTK 4.10, `GtkViewport` used the [enum@Gtk.AccessibleRole.group] role.
+ *
+ * Starting from GTK 4.12, `GtkViewport` uses the [enum@Gtk.AccessibleRole.generic] role.
+ */
 export declare class Viewport extends Widget {
+    /**
+     * Creates a new `GtkViewport`.
+     *
+     * The new viewport uses the given adjustments, or default
+     * adjustments if none are given.
+     * @param hadjustment - horizontal adjustment
+     * @param vadjustment - vertical adjustment
+     */
     constructor(hadjustment?: Adjustment | null, vadjustment?: Adjustment | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the child widget of @viewport.
+     */
     getChild(): Widget | null;
+    /**
+     * Gets whether the viewport is scrolling to keep the focused
+     * child in view.
+     */
     getScrollToFocus(): boolean;
+    /**
+     * Scrolls a descendant of the viewport into view.
+     *
+     * The viewport and the descendant must be visible and mapped for
+     * this function to work, otherwise no scrolling will be performed.
+     * @param descendant - a descendant widget of the viewport
+     * @param scroll - details of how to perform
+     */
     scrollTo(descendant: Widget, scroll?: ScrollInfo | null): void;
+    /**
+     * Sets the child widget of @viewport.
+     * @param child - the child widget
+     */
     setChild(child?: Widget | null): void;
+    /**
+     * Sets whether the viewport should automatically scroll
+     * to keep the focused child in view.
+     * @param scrollToFocus - whether to keep the focus widget scrolled to view
+     */
     setScrollToFocus(scrollToFocus: boolean): void;
+    /**
+     * Returns the size of a non-scrolling border around the
+     * outside of the scrollable.
+     *
+     * An example for this would be treeview headers. GTK can use
+     * this information to display overlaid graphics, like the
+     * overshoot indication, at the right position.
+     * @param border - return location for the results
+     */
     getBorder(border: Ref<Border>): boolean;
+    /**
+     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+     */
     getHadjustment(): Adjustment | null;
+    /**
+     * Gets the horizontal `GtkScrollablePolicy`.
+     */
     getHscrollPolicy(): ScrollablePolicy;
+    /**
+     * Retrieves the `GtkAdjustment` used for vertical scrolling.
+     */
     getVadjustment(): Adjustment | null;
+    /**
+     * Gets the vertical `GtkScrollablePolicy`.
+     */
     getVscrollPolicy(): ScrollablePolicy;
+    /**
+     * Sets the horizontal adjustment of the `GtkScrollable`.
+     * @param hadjustment - a `GtkAdjustment`
+     */
     setHadjustment(hadjustment?: Adjustment | null): void;
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether horizontal scrolling should start
+     * below the minimum width or below the natural width.
+     * @param policy - the horizontal `GtkScrollablePolicy`
+     */
     setHscrollPolicy(policy: ScrollablePolicy): void;
+    /**
+     * Sets the vertical adjustment of the `GtkScrollable`.
+     * @param vadjustment - a `GtkAdjustment`
+     */
     setVadjustment(vadjustment?: Adjustment | null): void;
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether vertical scrolling should start
+     * below the minimum height or below the natural height.
+     * @param policy - the vertical `GtkScrollablePolicy`
+     */
     setVscrollPolicy(policy: ScrollablePolicy): void;
     connect(signal: "notify", handler: (self: Viewport, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;