@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/recent-manager.js

@@ -2,10 +2,80 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { RecentInfo } from "./recent-info.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Manages and looks up recently used files.
+ *
+ * Each recently used file is identified by its URI, and has meta-data
+ * associated to it, like the names and command lines of the applications
+ * that have registered it, the number of time each application has
+ * registered the same file, the mime type of the file and whether
+ * the file should be displayed only by the applications that have
+ * registered it.
+ *
+ * The recently used files list is per user.
+ *
+ * `GtkRecentManager` acts like a database of all the recently
+ * used files. You can create new `GtkRecentManager` objects, but
+ * it is more efficient to use the default manager created by GTK.
+ *
+ * Adding a new recently used file is as simple as:
+ *
+ * ```c
+ * GtkRecentManager *manager;
+ *
+ * manager = gtk_recent_manager_get_default ();
+ * gtk_recent_manager_add_item (manager, file_uri);
+ * ```
+ *
+ * The `GtkRecentManager` will try to gather all the needed information
+ * from the file itself through GIO.
+ *
+ * Looking up the meta-data associated with a recently used file
+ * given its URI requires calling [method@Gtk.RecentManager.lookup_item]:
+ *
+ * ```c
+ * GtkRecentManager *manager;
+ * GtkRecentInfo *info;
+ * GError *error = NULL;
+ *
+ * manager = gtk_recent_manager_get_default ();
+ * info = gtk_recent_manager_lookup_item (manager, file_uri, &error);
+ * if (error)
+ * {
+ * g_warning ("Could not find the file: %s", error->message);
+ * g_error_free (error);
+ * }
+ * else
+ * {
+ * // Use the info object
+ * gtk_recent_info_unref (info);
+ * }
+ * ```
+ *
+ * In order to retrieve the list of recently used files, you can use
+ * [method@Gtk.RecentManager.get_items], which returns a list of
+ * [struct@Gtk.RecentInfo].
+ *
+ * Note that the maximum age of the recently used files list is
+ * controllable through the [property@Gtk.Settings:gtk-recent-files-max-age]
+ * property.
+ */
 const SIGNAL_META = {
     changed: { params: [], returnType: { type: "undefined" } },
 };
 export class RecentManager extends GObject.GObject {
+    /**
+     * Creates a new recent manager object.
+     *
+     * Recent manager objects are used to handle the list of recently used
+     * resources. A `GtkRecentManager` object monitors the recently used
+     * resources list, and emits the [signal@Gtk.RecentManager::changed]
+     * signal each time something inside the list changes.
+     *
+     * `GtkRecentManager` objects are expensive: be sure to create them
+     * only when needed. You should use [func@Gtk.RecentManager.get_default]
+     * instead.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -15,6 +85,10 @@ export class RecentManager extends GObject.GObject {
             borrowed: false,
         });
     }
+    /**
+     * Gets a unique instance of `GtkRecentManager` that you can share
+     * in your application without caring about memory management.
+     */
     static getDefault() {
         const ptr = call("libgtk-4.so.1", "gtk_recent_manager_get_default", [], {
             type: "gobject",
@@ -22,6 +96,29 @@ export class RecentManager extends GObject.GObject {
         });
         return getObject(ptr, RecentManager);
     }
+    /**
+     * Adds a new resource, pointed by @uri, into the recently used
+     * resources list, using the metadata specified inside the
+     * `GtkRecentData` passed in @recent_data.
+     *
+     * The passed URI will be used to identify this resource inside the
+     * list.
+     *
+     * In order to register the new recently used resource, metadata about
+     * the resource must be passed as well as the URI; the metadata is
+     * stored in a `GtkRecentData`, which must contain the MIME
+     * type of the resource pointed by the URI; the name of the application
+     * that is registering the item, and a command line to be used when
+     * launching the item.
+     *
+     * Optionally, a `GtkRecentData` might contain a UTF-8 string
+     * to be used when viewing the item instead of the last component of
+     * the URI; a short description of the item; whether the item should
+     * be considered private - that is, should be displayed only by the
+     * applications that have registered it.
+     * @param uri - a valid URI
+     * @param recentData - metadata of the resource
+     */
     addFull(uri, recentData) {
         return call("libgtk-4.so.1", "gtk_recent_manager_add_full", [
             {
@@ -38,6 +135,18 @@ export class RecentManager extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Adds a new resource, pointed by @uri, into the recently used
+     * resources list.
+     *
+     * This function automatically retrieves some of the needed
+     * metadata and setting other metadata to common default values;
+     * it then feeds the data to [method@Gtk.RecentManager.add_full].
+     *
+     * See [method@Gtk.RecentManager.add_full] if you want to explicitly
+     * define the metadata for the resource pointed by @uri.
+     * @param uri - a valid URI
+     */
     addItem(uri) {
         return call("libgtk-4.so.1", "gtk_recent_manager_add_item", [
             {
@@ -50,6 +159,9 @@ export class RecentManager extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the list of recently used resources.
+     */
     getItems() {
         return call("libgtk-4.so.1", "gtk_recent_manager_get_items", [
             {
@@ -67,6 +179,11 @@ export class RecentManager extends GObject.GObject {
             borrowed: true,
         });
     }
+    /**
+     * Checks whether there is a recently used resource registered
+     * with `uri` inside the recent manager.
+     * @param uri - a URI
+     */
     hasItem(uri) {
         return call("libgtk-4.so.1", "gtk_recent_manager_has_item", [
             {
@@ -79,6 +196,12 @@ export class RecentManager extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Searches for a URI inside the recently used resources list, and
+     * returns a `GtkRecentInfo` containing information about the resource
+     * like its MIME type, or its display name.
+     * @param uri - a URI
+     */
     lookupItem(uri) {
         const error = { value: null };
         const ptr = call("libgtk-4.so.1", "gtk_recent_manager_lookup_item", [
@@ -114,6 +237,14 @@ export class RecentManager extends GObject.GObject {
             return null;
         return getObject(ptr, RecentInfo);
     }
+    /**
+     * Changes the location of a recently used resource from `uri` to @new_uri.
+     *
+     * Please note that this function will not affect the resource pointed
+     * by the URIs, but only the URI used in the recently used resources list.
+     * @param uri - the URI of a recently used resource
+     * @param newUri - the new URI of the recently used resource, or
+     */
     moveItem(uri, newUri) {
         const error = { value: null };
         const result = call("libgtk-4.so.1", "gtk_recent_manager_move_item", [
@@ -147,6 +278,9 @@ export class RecentManager extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Purges every item from the recently used resources list.
+     */
     purgeItems() {
         const error = { value: null };
         const result = call("libgtk-4.so.1", "gtk_recent_manager_purge_items", [
@@ -171,6 +305,11 @@ export class RecentManager extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Removes a resource pointed by `uri` from the recently used resources
+     * list handled by a recent manager.
+     * @param uri - the URI of the item you wish to remove
+     */
     removeItem(uri) {
         const error = { value: null };
         const result = call("libgtk-4.so.1", "gtk_recent_manager_remove_item", [

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

@@ -1,11 +1,30 @@
+/**
+ * Represents the desired size of a widget.
+ *
+ * See GtkWidget’s geometry management section
+ * for more information.
+ */
 export declare class Requisition {
     ptr: unknown;
+    /**
+     * Allocates a new `GtkRequisition`.
+     *
+     * The struct is initialized to zero.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Copies a `GtkRequisition`.
+     */
     copy(): Requisition;
+    /**
+     * Frees a `GtkRequisition`.
+     */
     free(): void;
+    /** the widget’s desired width */
     get width(): number;
     set width(value: number);
+    /** the widget’s desired height */
     get height(): number;
     set height(value: number);
 }

package/dist/generated/gtk/requisition.js

@@ -1,7 +1,18 @@
 import { call, read, write } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * Represents the desired size of a widget.
+ *
+ * See GtkWidget’s geometry management section
+ * for more information.
+ */
 export class Requisition {
     ptr;
+    /**
+     * Allocates a new `GtkRequisition`.
+     *
+     * The struct is initialized to zero.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +23,9 @@ export class Requisition {
             innerType: "GtkRequisition",
         });
     }
+    /**
+     * Copies a `GtkRequisition`.
+     */
     copy() {
         const ptr = call("libgtk-4.so.1", "gtk_requisition_copy", [
             {
@@ -26,6 +40,9 @@ export class Requisition {
         });
         return getObject(ptr, Requisition);
     }
+    /**
+     * Frees a `GtkRequisition`.
+     */
     free() {
         call("libgtk-4.so.1", "gtk_requisition_free", [
             {
@@ -34,12 +51,14 @@ export class Requisition {
             },
         ], { type: "undefined" });
     }
+    /** the widget’s desired width */
     get width() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 0);
     }
     set width(value) {
         write(this.ptr, { type: "int", size: 32, unsigned: false }, 0, value);
     }
+    /** the widget’s desired height */
     get height() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 4);
     }

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

@@ -1,17 +1,90 @@
 import { RevealerTransitionType } from "./enums.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Animates the transition of its child from invisible to visible.
+ *
+ * The style of transition can be controlled with
+ * [method@Gtk.Revealer.set_transition_type].
+ *
+ * These animations respect the [property@Gtk.Settings:gtk-enable-animations]
+ * setting.
+ *
+ * # CSS nodes
+ *
+ * `GtkRevealer` has a single CSS node with name revealer.
+ * When styling `GtkRevealer` using CSS, remember that it only hides its contents,
+ * not itself. That means applied margin, padding and borders will be visible even
+ * when the [property@Gtk.Revealer:reveal-child] property is set to %FALSE.
+ *
+ * # Accessibility
+ *
+ * `GtkRevealer` uses the [enum@Gtk.AccessibleRole.group] role.
+ *
+ * The child of `GtkRevealer`, if set, is always available in the accessibility
+ * tree, regardless of the state of the revealer widget.
+ */
 export declare class Revealer extends Widget {
+    /**
+     * Creates a new `GtkRevealer`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the child widget of @revealer.
+     */
     getChild(): Widget | null;
+    /**
+     * Returns whether the child is fully revealed.
+     *
+     * In other words, this returns whether the transition
+     * to the revealed state is completed.
+     */
     getChildRevealed(): boolean;
+    /**
+     * Returns whether the child is currently revealed.
+     *
+     * This function returns %TRUE as soon as the transition
+     * is to the revealed state is started. To learn whether
+     * the child is fully revealed (ie the transition is completed),
+     * use [method@Gtk.Revealer.get_child_revealed].
+     */
     getRevealChild(): boolean;
+    /**
+     * Returns the amount of time (in milliseconds) that
+     * transitions will take.
+     */
     getTransitionDuration(): number;
+    /**
+     * Gets the type of animation that will be used
+     * for transitions in @revealer.
+     */
     getTransitionType(): RevealerTransitionType;
+    /**
+     * Sets the child widget of @revealer.
+     * @param child - the child widget
+     */
     setChild(child?: Widget | null): void;
+    /**
+     * Tells the `GtkRevealer` to reveal or conceal its child.
+     *
+     * The transition will be animated with the current
+     * transition type of @revealer.
+     * @param revealChild - %TRUE to reveal the child
+     */
     setRevealChild(revealChild: boolean): void;
+    /**
+     * Sets the duration that transitions will take.
+     * @param duration - the new duration, in milliseconds
+     */
     setTransitionDuration(duration: number): void;
+    /**
+     * Sets the type of animation that will be used for
+     * transitions in @revealer.
+     *
+     * Available types include various kinds of fades and slides.
+     * @param transition - the new transition type
+     */
     setTransitionType(transition: RevealerTransitionType): void;
     connect(signal: "notify", handler: (self: Revealer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/revealer.js

@@ -1,7 +1,33 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
+/**
+ * Animates the transition of its child from invisible to visible.
+ *
+ * The style of transition can be controlled with
+ * [method@Gtk.Revealer.set_transition_type].
+ *
+ * These animations respect the [property@Gtk.Settings:gtk-enable-animations]
+ * setting.
+ *
+ * # CSS nodes
+ *
+ * `GtkRevealer` has a single CSS node with name revealer.
+ * When styling `GtkRevealer` using CSS, remember that it only hides its contents,
+ * not itself. That means applied margin, padding and borders will be visible even
+ * when the [property@Gtk.Revealer:reveal-child] property is set to %FALSE.
+ *
+ * # Accessibility
+ *
+ * `GtkRevealer` uses the [enum@Gtk.AccessibleRole.group] role.
+ *
+ * The child of `GtkRevealer`, if set, is always available in the accessibility
+ * tree, regardless of the state of the revealer widget.
+ */
 export class Revealer extends Widget {
+    /**
+     * Creates a new `GtkRevealer`.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -11,6 +37,9 @@ export class Revealer extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Gets the child widget of @revealer.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_revealer_get_child", [
             {
@@ -22,6 +51,12 @@ export class Revealer extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns whether the child is fully revealed.
+     *
+     * In other words, this returns whether the transition
+     * to the revealed state is completed.
+     */
     getChildRevealed() {
         return call("libgtk-4.so.1", "gtk_revealer_get_child_revealed", [
             {
@@ -30,6 +65,14 @@ export class Revealer extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the child is currently revealed.
+     *
+     * This function returns %TRUE as soon as the transition
+     * is to the revealed state is started. To learn whether
+     * the child is fully revealed (ie the transition is completed),
+     * use [method@Gtk.Revealer.get_child_revealed].
+     */
     getRevealChild() {
         return call("libgtk-4.so.1", "gtk_revealer_get_reveal_child", [
             {
@@ -38,6 +81,10 @@ export class Revealer extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the amount of time (in milliseconds) that
+     * transitions will take.
+     */
     getTransitionDuration() {
         return call("libgtk-4.so.1", "gtk_revealer_get_transition_duration", [
             {
@@ -46,6 +93,10 @@ export class Revealer extends Widget {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the type of animation that will be used
+     * for transitions in @revealer.
+     */
     getTransitionType() {
         return call("libgtk-4.so.1", "gtk_revealer_get_transition_type", [
             {
@@ -54,6 +105,10 @@ export class Revealer extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the child widget of @revealer.
+     * @param child - the child widget
+     */
     setChild(child) {
         call("libgtk-4.so.1", "gtk_revealer_set_child", [
             {
@@ -67,6 +122,13 @@ export class Revealer extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Tells the `GtkRevealer` to reveal or conceal its child.
+     *
+     * The transition will be animated with the current
+     * transition type of @revealer.
+     * @param revealChild - %TRUE to reveal the child
+     */
     setRevealChild(revealChild) {
         call("libgtk-4.so.1", "gtk_revealer_set_reveal_child", [
             {
@@ -79,6 +141,10 @@ export class Revealer extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the duration that transitions will take.
+     * @param duration - the new duration, in milliseconds
+     */
     setTransitionDuration(duration) {
         call("libgtk-4.so.1", "gtk_revealer_set_transition_duration", [
             {
@@ -91,6 +157,13 @@ export class Revealer extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the type of animation that will be used for
+     * transitions in @revealer.
+     *
+     * Available types include various kinds of fades and slides.
+     * @param transition - the new transition type
+     */
     setTransitionType(transition) {
         call("libgtk-4.so.1", "gtk_revealer_set_transition_type", [
             {

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

@@ -1,10 +1,47 @@
 import { Widget } from "./widget.js";
 import * as Gdk from "../gdk/index.js";
+/**
+ * An interface for widgets that can act as the root of a widget hierarchy.
+ *
+ * The root widget takes care of providing the connection to the windowing
+ * system and manages layout, drawing and event delivery for its widget
+ * hierarchy.
+ *
+ * The obvious example of a `GtkRoot` is `GtkWindow`.
+ *
+ * To get the display to which a `GtkRoot` belongs, use
+ * [method@Gtk.Root.get_display].
+ *
+ * `GtkRoot` also maintains the location of keyboard focus inside its widget
+ * hierarchy, with [method@Gtk.Root.set_focus] and [method@Gtk.Root.get_focus].
+ */
 export declare class Root {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Root;
+    /**
+     * Returns the display that this `GtkRoot` is on.
+     */
     getDisplay(): Gdk.Display;
+    /**
+     * Retrieves the current focused widget within the root.
+     *
+     * Note that this is the widget that would have the focus
+     * if the root is active; if the root is not focused then
+     * `gtk_widget_has_focus (widget)` will be %FALSE for the
+     * widget.
+     */
     getFocus(): Widget | null;
+    /**
+     * If `focus` is not the current focus widget, and is focusable, sets
+     * it as the focus widget for the root.
+     *
+     * If `focus` is %NULL, unsets the focus widget for the root.
+     *
+     * To set the focus to a particular widget in the root, it is usually
+     * more convenient to use [method@Gtk.Widget.grab_focus] instead of
+     * this function.
+     * @param focus - widget to be the new focus widget, or %NULL
+     */
     setFocus(focus?: Widget | null): void;
 }

package/dist/generated/gtk/root.js

@@ -2,6 +2,21 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 import * as Gdk from "../gdk/index.js";
+/**
+ * An interface for widgets that can act as the root of a widget hierarchy.
+ *
+ * The root widget takes care of providing the connection to the windowing
+ * system and manages layout, drawing and event delivery for its widget
+ * hierarchy.
+ *
+ * The obvious example of a `GtkRoot` is `GtkWindow`.
+ *
+ * To get the display to which a `GtkRoot` belongs, use
+ * [method@Gtk.Root.get_display].
+ *
+ * `GtkRoot` also maintains the location of keyboard focus inside its widget
+ * hierarchy, with [method@Gtk.Root.set_focus] and [method@Gtk.Root.get_focus].
+ */
 export class Root {
     ptr;
     constructor(ptr) {
@@ -10,6 +25,9 @@ export class Root {
     static fromPtr(ptr) {
         return new Root(ptr);
     }
+    /**
+     * Returns the display that this `GtkRoot` is on.
+     */
     getDisplay() {
         const ptr = call("libgtk-4.so.1", "gtk_root_get_display", [
             {
@@ -19,6 +37,14 @@ export class Root {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gdk.Display);
     }
+    /**
+     * Retrieves the current focused widget within the root.
+     *
+     * Note that this is the widget that would have the focus
+     * if the root is active; if the root is not focused then
+     * `gtk_widget_has_focus (widget)` will be %FALSE for the
+     * widget.
+     */
     getFocus() {
         const ptr = call("libgtk-4.so.1", "gtk_root_get_focus", [
             {
@@ -30,6 +56,17 @@ export class Root {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * If `focus` is not the current focus widget, and is focusable, sets
+     * it as the focus widget for the root.
+     *
+     * If `focus` is %NULL, unsets the focus widget for the root.
+     *
+     * To set the focus to a particular widget in the root, it is usually
+     * more convenient to use [method@Gtk.Widget.grab_focus] instead of
+     * this function.
+     * @param focus - widget to be the new focus widget, or %NULL
+     */
     setFocus(focus) {
         call("libgtk-4.so.1", "gtk_root_set_focus", [
             {