@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gdk/texture.js

@@ -4,10 +4,56 @@ import { ColorState } from "./color-state.js";
 import { Paintable } from "./paintable.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Refers to pixel data in various forms.
+ *
+ * It is primarily meant for pixel data that will not change over
+ * multiple frames, and will be used for a long time.
+ *
+ * There are various ways to create `GdkTexture` objects from a
+ * [class@GdkPixbuf.Pixbuf], or from bytes stored in memory, a file, or a
+ * [struct@Gio.Resource].
+ *
+ * The ownership of the pixel data is transferred to the `GdkTexture`
+ * instance; you can only make a copy of it, via [method@Gdk.Texture.download].
+ *
+ * `GdkTexture` is an immutable object: That means you cannot change
+ * anything about it other than increasing the reference count via
+ * [method@GObject.Object.ref], and consequently, it is a threadsafe object.
+ *
+ * GDK provides a number of threadsafe texture loading functions:
+ * [ctor@Gdk.Texture.new_from_resource],
+ * [ctor@Gdk.Texture.new_from_bytes],
+ * [ctor@Gdk.Texture.new_from_file],
+ * [ctor@Gdk.Texture.new_from_filename],
+ * [ctor@Gdk.Texture.new_for_pixbuf]. Note that these are meant for loading
+ * icons and resources that are shipped with the toolkit or application. It
+ * is recommended that you use a dedicated image loading framework such as
+ * [glycin](https://lib.rs/crates/glycin), if you need to load untrusted image
+ * data.
+ */
 export class Texture extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new texture by loading an image from memory,
+     *
+     * The file format is detected automatically. The supported formats
+     * are PNG, JPEG and TIFF, though more formats might be available.
+     *
+     * If `NULL` is returned, then `error` will be set.
+     *
+     * This function is threadsafe, so that you can e.g. use GTask
+     * and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
+     * while loading a big image.
+     *
+     * ::: warning
+     * Note that this function should not be used with untrusted data.
+     * Use a proper image loading framework such as libglycin, which can
+     * load many image formats into a `GdkTexture`.
+     * @param bytes - a `GBytes` containing the data to load
+     */
     static newFromBytes(bytes) {
         const ptr = call("libgtk-4.so.1", "gdk_texture_new_from_bytes", [
             {
@@ -22,6 +68,24 @@ export class Texture extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Texture);
     }
+    /**
+     * Creates a new texture by loading an image from a file.
+     *
+     * The file format is detected automatically. The supported formats
+     * are PNG, JPEG and TIFF, though more formats might be available.
+     *
+     * If `NULL` is returned, then `error` will be set.
+     *
+     * This function is threadsafe, so that you can e.g. use GTask
+     * and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
+     * while loading a big image.
+     *
+     * ::: warning
+     * Note that this function should not be used with untrusted data.
+     * Use a proper image loading framework such as libglycin, which can
+     * load many image formats into a `GdkTexture`.
+     * @param file - `GFile` to load
+     */
     static newFromFile(file) {
         const ptr = call("libgtk-4.so.1", "gdk_texture_new_from_file", [
             {
@@ -31,6 +95,24 @@ export class Texture extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Texture);
     }
+    /**
+     * Creates a new texture by loading an image from a file.
+     *
+     * The file format is detected automatically. The supported formats
+     * are PNG, JPEG and TIFF, though more formats might be available.
+     *
+     * If `NULL` is returned, then `error` will be set.
+     *
+     * This function is threadsafe, so that you can e.g. use GTask
+     * and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
+     * while loading a big image.
+     *
+     * ::: warning
+     * Note that this function should not be used with untrusted data.
+     * Use a proper image loading framework such as libglycin, which can
+     * load many image formats into a `GdkTexture`.
+     * @param path - the filename to load
+     */
     static newFromFilename(path) {
         const ptr = call("libgtk-4.so.1", "gdk_texture_new_from_filename", [
             {
@@ -40,6 +122,22 @@ export class Texture extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Texture);
     }
+    /**
+     * Creates a new texture by loading an image from a resource.
+     *
+     * The file format is detected automatically. The supported formats
+     * are PNG, JPEG and TIFF, though more formats might be available.
+     *
+     * It is a fatal error if `resource_path` does not specify a valid
+     * image resource and the program will abort if that happens.
+     * If you are unsure about the validity of a resource, use
+     * [ctor@Gdk.Texture.new_from_file] to load it.
+     *
+     * This function is threadsafe, so that you can e.g. use GTask
+     * and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
+     * while loading a big image.
+     * @param resourcePath - the path of the resource file
+     */
     static newFromResource(resourcePath) {
         const ptr = call("libgtk-4.so.1", "gdk_texture_new_from_resource", [
             {
@@ -58,6 +156,32 @@ export class Texture extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Downloads the `texture` into local memory.
+     *
+     * This may be an expensive operation, as the actual texture data
+     * may reside on a GPU or on a remote display server.
+     *
+     * The data format of the downloaded data is equivalent to
+     * %CAIRO_FORMAT_ARGB32, so every downloaded pixel requires
+     * 4 bytes of memory.
+     *
+     * Downloading a texture into a Cairo image surface:
+     * ```c
+     * surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
+     * gdk_texture_get_width (texture),
+     * gdk_texture_get_height (texture));
+     * gdk_texture_download (texture,
+     * cairo_image_surface_get_data (surface),
+     * cairo_image_surface_get_stride (surface));
+     * cairo_surface_mark_dirty (surface);
+     * ```
+     *
+     * For more flexible download capabilities, see
+     * [struct@Gdk.TextureDownloader].
+     * @param data - pointer to enough memory to be filled with the
+     * @param stride - rowstride in bytes
+     */
     download(data, stride) {
         call("libgtk-4.so.1", "gdk_texture_download", [
             {
@@ -77,6 +201,9 @@ export class Texture extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the color state associated with the texture.
+     */
     getColorState() {
         const ptr = call("libgtk-4.so.1", "gdk_texture_get_color_state", [
             {
@@ -91,6 +218,17 @@ export class Texture extends GObject.GObject {
         });
         return getObject(ptr, ColorState);
     }
+    /**
+     * Gets the memory format most closely associated with the data of
+     * the texture.
+     *
+     * Note that it may not be an exact match for texture data
+     * stored on the GPU or with compression.
+     *
+     * The format can give an indication about the bit depth and opacity
+     * of the texture and is useful to determine the best format for
+     * downloading the texture.
+     */
     getFormat() {
         return call("libgtk-4.so.1", "gdk_texture_get_format", [
             {
@@ -99,6 +237,9 @@ export class Texture extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the height of the @texture, in pixels.
+     */
     getHeight() {
         return call("libgtk-4.so.1", "gdk_texture_get_height", [
             {
@@ -107,6 +248,9 @@ export class Texture extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the width of @texture, in pixels.
+     */
     getWidth() {
         return call("libgtk-4.so.1", "gdk_texture_get_width", [
             {
@@ -115,6 +259,16 @@ export class Texture extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Store the given `texture` to the `filename` as a PNG file.
+     *
+     * This is a utility function intended for debugging and testing.
+     * If you want more control over formats, proper error handling or
+     * want to store to a [iface@Gio.File] or other location, you might
+     * want to use [method@Gdk.Texture.save_to_png_bytes] or look into
+     * the libglycin library.
+     * @param filename - the filename to store to
+     */
     saveToPng(filename) {
         return call("libgtk-4.so.1", "gdk_texture_save_to_png", [
             {
@@ -127,6 +281,22 @@ export class Texture extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Store the given `texture` in memory as a PNG file.
+     *
+     * Use [ctor@Gdk.Texture.new_from_bytes] to read it back.
+     *
+     * If you want to serialize a texture, this is a convenient and
+     * portable way to do that.
+     *
+     * If you need more control over the generated image, such as
+     * attaching metadata, you should look into an image handling
+     * library such as the libglycin library.
+     *
+     * If you are dealing with high dynamic range float data, you
+     * might also want to consider [method@Gdk.Texture.save_to_tiff_bytes]
+     * instead.
+     */
     saveToPngBytes() {
         const ptr = call("libgtk-4.so.1", "gdk_texture_save_to_png_bytes", [
             {
@@ -141,6 +311,12 @@ export class Texture extends GObject.GObject {
         });
         return getObject(ptr, GLib.Bytes);
     }
+    /**
+     * Store the given `texture` to the `filename` as a TIFF file.
+     *
+     * GTK will attempt to store data without loss.
+     * @param filename - the filename to store to
+     */
     saveToTiff(filename) {
         return call("libgtk-4.so.1", "gdk_texture_save_to_tiff", [
             {
@@ -153,6 +329,20 @@ export class Texture extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Store the given `texture` in memory as a TIFF file.
+     *
+     * Use [ctor@Gdk.Texture.new_from_bytes] to read it back.
+     *
+     * This function is intended to store a representation of the
+     * texture's data that is as accurate as possible. This is
+     * particularly relevant when working with high dynamic range
+     * images and floating-point texture data.
+     *
+     * If that is not your concern and you are interested in a
+     * smaller size and a more portable format, you might want to
+     * use [method@Gdk.Texture.save_to_png_bytes].
+     */
     saveToTiffBytes() {
         const ptr = call("libgtk-4.so.1", "gdk_texture_save_to_tiff_bytes", [
             {
@@ -167,6 +357,23 @@ export class Texture extends GObject.GObject {
         });
         return getObject(ptr, GLib.Bytes);
     }
+    /**
+     * 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("libgtk-4.so.1", "gdk_paintable_compute_concrete_size", [
             {
@@ -199,6 +406,14 @@ export class Texture extends GObject.GObject {
             },
         ], { 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("libgtk-4.so.1", "gdk_paintable_get_current_image", [
             {
@@ -208,6 +423,13 @@ export class Texture extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, 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("libgtk-4.so.1", "gdk_paintable_get_flags", [
             {
@@ -216,6 +438,25 @@ export class Texture extends GObject.GObject {
             },
         ], { 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("libgtk-4.so.1", "gdk_paintable_get_intrinsic_aspect_ratio", [
             {
@@ -224,6 +465,18 @@ export class Texture extends GObject.GObject {
             },
         ], { 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("libgtk-4.so.1", "gdk_paintable_get_intrinsic_height", [
             {
@@ -232,6 +485,18 @@ export class Texture extends GObject.GObject {
             },
         ], { 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("libgtk-4.so.1", "gdk_paintable_get_intrinsic_width", [
             {
@@ -240,6 +505,18 @@ export class Texture extends GObject.GObject {
             },
         ], { 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("libgtk-4.so.1", "gdk_paintable_invalidate_contents", [
             {
@@ -248,6 +525,18 @@ export class Texture extends GObject.GObject {
             },
         ], { 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("libgtk-4.so.1", "gdk_paintable_invalidate_size", [
             {
@@ -256,6 +545,16 @@ export class Texture extends GObject.GObject {
             },
         ], { 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("libgtk-4.so.1", "gdk_paintable_snapshot", [
             {

package/dist/generated/gdk/toplevel-layout.d.ts

@@ -1,18 +1,87 @@
 import { Ref } from "@gtkx/native";
 import { Monitor } from "./monitor.js";
+/**
+ * Contains information that is necessary to present a sovereign
+ * window on screen.
+ *
+ * The `GdkToplevelLayout` struct is necessary for using
+ * [method@Gdk.Toplevel.present].
+ *
+ * Toplevel surfaces are sovereign windows that can be presented
+ * to the user in various states (maximized, on all workspaces,
+ * etc).
+ */
 export declare class ToplevelLayout {
     ptr: unknown;
+    /**
+     * Create a toplevel layout description.
+     *
+     * Used together with [method@Gdk.Toplevel.present] to describe
+     * how a toplevel surface should be placed and behave on-screen.
+     *
+     * The size is in ”application pixels”, not
+     * ”device pixels” (see [method@Gdk.Surface.get_scale]).
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Create a new `GdkToplevelLayout` and copy the contents of `layout` into it.
+     */
     copy(): ToplevelLayout;
+    /**
+     * Check whether `layout` and `other` has identical layout properties.
+     * @param other - another toplevel layout
+     */
     equal(other: ToplevelLayout): boolean;
+    /**
+     * If the layout specifies whether to the toplevel should go fullscreen,
+     * the value pointed to by `fullscreen` is set to true if it should go
+     * fullscreen, or false, if it should go unfullscreen.
+     * @param fullscreen - location to store whether the toplevel should be fullscreen
+     */
     getFullscreen(fullscreen: Ref<boolean>): boolean;
+    /**
+     * Returns the monitor that the layout is fullscreening
+     * the surface on.
+     */
     getFullscreenMonitor(): Monitor | null;
+    /**
+     * If the layout specifies whether to the toplevel should go maximized,
+     * the value pointed to by `maximized` is set to true if it should go
+     * maximized, or false, if it should go unmaximized.
+     * @param maximized - set to true if the toplevel should be maximized
+     */
     getMaximized(maximized: Ref<boolean>): boolean;
+    /**
+     * Returns whether the layout should allow the user
+     * to resize the surface.
+     */
     getResizable(): boolean;
+    /**
+     * Increases the reference count of @layout.
+     */
     ref(): ToplevelLayout;
+    /**
+     * Sets whether the layout should cause the surface
+     * to be fullscreen when presented.
+     * @param fullscreen - true to fullscreen the surface
+     * @param monitor - the monitor to fullscreen on
+     */
     setFullscreen(fullscreen: boolean, monitor?: Monitor | null): void;
+    /**
+     * Sets whether the layout should cause the surface
+     * to be maximized when presented.
+     * @param maximized - true to maximize
+     */
     setMaximized(maximized: boolean): void;
+    /**
+     * Sets whether the layout should allow the user
+     * to resize the surface after it has been presented.
+     * @param resizable - true to allow resizing
+     */
     setResizable(resizable: boolean): void;
+    /**
+     * Decreases the reference count of @layout.
+     */
     unref(): void;
 }

package/dist/generated/gdk/toplevel-layout.js

@@ -1,8 +1,28 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Monitor } from "./monitor.js";
+/**
+ * Contains information that is necessary to present a sovereign
+ * window on screen.
+ *
+ * The `GdkToplevelLayout` struct is necessary for using
+ * [method@Gdk.Toplevel.present].
+ *
+ * Toplevel surfaces are sovereign windows that can be presented
+ * to the user in various states (maximized, on all workspaces,
+ * etc).
+ */
 export class ToplevelLayout {
     ptr;
+    /**
+     * Create a toplevel layout description.
+     *
+     * Used together with [method@Gdk.Toplevel.present] to describe
+     * how a toplevel surface should be placed and behave on-screen.
+     *
+     * The size is in ”application pixels”, not
+     * ”device pixels” (see [method@Gdk.Surface.get_scale]).
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -13,6 +33,9 @@ export class ToplevelLayout {
             innerType: "GdkToplevelLayout",
         });
     }
+    /**
+     * Create a new `GdkToplevelLayout` and copy the contents of `layout` into it.
+     */
     copy() {
         const ptr = call("libgtk-4.so.1", "gdk_toplevel_layout_copy", [
             {
@@ -27,6 +50,10 @@ export class ToplevelLayout {
         });
         return getObject(ptr, ToplevelLayout);
     }
+    /**
+     * Check whether `layout` and `other` has identical layout properties.
+     * @param other - another toplevel layout
+     */
     equal(other) {
         return call("libgtk-4.so.1", "gdk_toplevel_layout_equal", [
             {
@@ -44,6 +71,12 @@ export class ToplevelLayout {
             },
         ], { type: "boolean" });
     }
+    /**
+     * If the layout specifies whether to the toplevel should go fullscreen,
+     * the value pointed to by `fullscreen` is set to true if it should go
+     * fullscreen, or false, if it should go unfullscreen.
+     * @param fullscreen - location to store whether the toplevel should be fullscreen
+     */
     getFullscreen(fullscreen) {
         return call("libgtk-4.so.1", "gdk_toplevel_layout_get_fullscreen", [
             {
@@ -56,6 +89,10 @@ export class ToplevelLayout {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the monitor that the layout is fullscreening
+     * the surface on.
+     */
     getFullscreenMonitor() {
         const ptr = call("libgtk-4.so.1", "gdk_toplevel_layout_get_fullscreen_monitor", [
             {
@@ -67,6 +104,12 @@ export class ToplevelLayout {
             return null;
         return getObject(ptr, Monitor);
     }
+    /**
+     * If the layout specifies whether to the toplevel should go maximized,
+     * the value pointed to by `maximized` is set to true if it should go
+     * maximized, or false, if it should go unmaximized.
+     * @param maximized - set to true if the toplevel should be maximized
+     */
     getMaximized(maximized) {
         return call("libgtk-4.so.1", "gdk_toplevel_layout_get_maximized", [
             {
@@ -79,6 +122,10 @@ export class ToplevelLayout {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the layout should allow the user
+     * to resize the surface.
+     */
     getResizable() {
         return call("libgtk-4.so.1", "gdk_toplevel_layout_get_resizable", [
             {
@@ -87,6 +134,9 @@ export class ToplevelLayout {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Increases the reference count of @layout.
+     */
     ref() {
         const ptr = call("libgtk-4.so.1", "gdk_toplevel_layout_ref", [
             {
@@ -101,6 +151,12 @@ export class ToplevelLayout {
         });
         return getObject(ptr, ToplevelLayout);
     }
+    /**
+     * Sets whether the layout should cause the surface
+     * to be fullscreen when presented.
+     * @param fullscreen - true to fullscreen the surface
+     * @param monitor - the monitor to fullscreen on
+     */
     setFullscreen(fullscreen, monitor) {
         call("libgtk-4.so.1", "gdk_toplevel_layout_set_fullscreen", [
             {
@@ -118,6 +174,11 @@ export class ToplevelLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the layout should cause the surface
+     * to be maximized when presented.
+     * @param maximized - true to maximize
+     */
     setMaximized(maximized) {
         call("libgtk-4.so.1", "gdk_toplevel_layout_set_maximized", [
             {
@@ -130,6 +191,11 @@ export class ToplevelLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the layout should allow the user
+     * to resize the surface after it has been presented.
+     * @param resizable - true to allow resizing
+     */
     setResizable(resizable) {
         call("libgtk-4.so.1", "gdk_toplevel_layout_set_resizable", [
             {
@@ -142,6 +208,9 @@ export class ToplevelLayout {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decreases the reference count of @layout.
+     */
     unref() {
         call("libgtk-4.so.1", "gdk_toplevel_layout_unref", [
             {