@gtkx/ffi 0.1.44 → 0.1.46

package/dist/generated/gdk/monitor.js

@@ -2,6 +2,14 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Display } from "./display.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Represents the individual outputs that are associated with a `GdkDisplay`.
+ *
+ * `GdkDisplay` keeps a `GListModel` to enumerate and monitor
+ * monitors with [method@Gdk.Display.get_monitors]. You can use
+ * [method@Gdk.Display.get_monitor_at_surface] to find a particular
+ * monitor.
+ */
 const SIGNAL_META = {
     invalidate: { params: [], returnType: { type: "undefined" } },
 };
@@ -20,6 +28,13 @@ export class Monitor extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the name of the monitor's connector, if available.
+     *
+     * These are strings such as "eDP-1", or "HDMI-2". They depend
+     * on software and hardware configuration, and should not be
+     * relied on as stable identifiers of a specific monitor.
+     */
     getConnector() {
         return call("libgtk-4.so.1", "gdk_monitor_get_connector", [
             {
@@ -28,6 +43,11 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets a string describing the monitor, if available.
+     *
+     * This can be used to identify a monitor in the UI.
+     */
     getDescription() {
         return call("libgtk-4.so.1", "gdk_monitor_get_description", [
             {
@@ -36,6 +56,9 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the display that this monitor belongs to.
+     */
     getDisplay() {
         const ptr = call("libgtk-4.so.1", "gdk_monitor_get_display", [
             {
@@ -45,6 +68,14 @@ export class Monitor extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Display);
     }
+    /**
+     * Retrieves the size and position of the monitor within the
+     * display coordinate space.
+     *
+     * The returned geometry is in  ”application pixels”, not in
+     * ”device pixels” (see [method@Gdk.Monitor.get_scale]).
+     * @param geometry - a `GdkRectangle` to be filled with the monitor geometry
+     */
     getGeometry(geometry) {
         call("libgtk-4.so.1", "gdk_monitor_get_geometry", [
             {
@@ -64,6 +95,9 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the height in millimeters of the monitor.
+     */
     getHeightMm() {
         return call("libgtk-4.so.1", "gdk_monitor_get_height_mm", [
             {
@@ -72,6 +106,15 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the name or PNP ID of the monitor's manufacturer.
+     *
+     * Note that this value might also vary depending on actual
+     * display backend.
+     *
+     * The PNP ID registry is located at
+     * [https://uefi.org/pnp_id_list](https://uefi.org/pnp_id_list).
+     */
     getManufacturer() {
         return call("libgtk-4.so.1", "gdk_monitor_get_manufacturer", [
             {
@@ -80,6 +123,9 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the string identifying the monitor model, if available.
+     */
     getModel() {
         return call("libgtk-4.so.1", "gdk_monitor_get_model", [
             {
@@ -88,6 +134,12 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the refresh rate of the monitor, if available.
+     *
+     * The value is in milli-Hertz, so a refresh rate of 60Hz
+     * is returned as 60000.
+     */
     getRefreshRate() {
         return call("libgtk-4.so.1", "gdk_monitor_get_refresh_rate", [
             {
@@ -96,6 +148,14 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the internal scale factor that maps from monitor coordinates
+     * to device pixels.
+     *
+     * This can be used if you want to create pixel based data for a
+     * particular monitor, but most of the time you’re drawing to a surface
+     * where it is better to use [method@Gdk.Surface.get_scale] instead.
+     */
     getScale() {
         return call("libgtk-4.so.1", "gdk_monitor_get_scale", [
             {
@@ -104,6 +164,17 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Gets the internal scale factor that maps from monitor coordinates
+     * to device pixels.
+     *
+     * On traditional systems this is 1, but on very high density outputs
+     * it can be a higher value (often 2).
+     *
+     * This can be used if you want to create pixel based data for a
+     * particular monitor, but most of the time you’re drawing to a surface
+     * where it is better to use [method@Gdk.Surface.get_scale_factor] instead.
+     */
     getScaleFactor() {
         return call("libgtk-4.so.1", "gdk_monitor_get_scale_factor", [
             {
@@ -112,6 +183,10 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets information about the layout of red, green and blue
+     * primaries for pixels.
+     */
     getSubpixelLayout() {
         return call("libgtk-4.so.1", "gdk_monitor_get_subpixel_layout", [
             {
@@ -120,6 +195,9 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the width in millimeters of the monitor.
+     */
     getWidthMm() {
         return call("libgtk-4.so.1", "gdk_monitor_get_width_mm", [
             {
@@ -128,6 +206,13 @@ export class Monitor extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns %TRUE if the `monitor` object corresponds to a
+     * physical monitor.
+     *
+     * The `monitor` becomes invalid when the physical monitor
+     * is unplugged or removed.
+     */
     isValid() {
         return call("libgtk-4.so.1", "gdk_monitor_is_valid", [
             {

package/dist/generated/gdk/motion-event.d.ts

@@ -1,4 +1,5 @@
 import { Event } from "./event.js";
+/** An event related to a pointer or touch device motion. */
 export declare class MotionEvent extends Event {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;

package/dist/generated/gdk/motion-event.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { Event } from "./event.js";
+/** An event related to a pointer or touch device motion. */
 export class MotionEvent extends Event {
     constructor(...args) {
         super(...args);

package/dist/generated/gdk/pad-event.d.ts

@@ -1,9 +1,24 @@
 import { Ref } from "@gtkx/native";
 import { Event } from "./event.js";
+/** An event related to a pad-based device. */
 export declare class PadEvent extends Event {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Extracts the information from a pad strip or ring event.
+     * @param index - Return location for the axis index
+     * @param value - Return location for the axis value
+     */
     getAxisValue(index: Ref<number>, value: Ref<number>): void;
+    /**
+     * Extracts information about the pressed button from
+     * a pad event.
+     */
     getButton(): number;
+    /**
+     * Extracts group and mode information from a pad event.
+     * @param group - return location for the group
+     * @param mode - return location for the mode
+     */
     getGroupMode(group: Ref<number>, mode: Ref<number>): void;
 }

package/dist/generated/gdk/pad-event.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { Event } from "./event.js";
+/** An event related to a pad-based device. */
 export class PadEvent extends Event {
     constructor(...args) {
         super(...args);
@@ -15,6 +16,11 @@ export class PadEvent extends Event {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Extracts the information from a pad strip or ring event.
+     * @param index - Return location for the axis index
+     * @param value - Return location for the axis value
+     */
     getAxisValue(index, value) {
         call("libgtk-4.so.1", "gdk_pad_event_get_axis_value", [
             {
@@ -34,6 +40,10 @@ export class PadEvent extends Event {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Extracts information about the pressed button from
+     * a pad event.
+     */
     getButton() {
         return call("libgtk-4.so.1", "gdk_pad_event_get_button", [
             {
@@ -42,6 +52,11 @@ export class PadEvent extends Event {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Extracts group and mode information from a pad event.
+     * @param group - return location for the group
+     * @param mode - return location for the mode
+     */
     getGroupMode(group, mode) {
         call("libgtk-4.so.1", "gdk_pad_event_get_group_mode", [
             {

package/dist/generated/gdk/paintable.d.ts

@@ -1,17 +1,172 @@
 import { Ref } from "@gtkx/native";
 import { PaintableFlags } from "./enums.js";
 import { Snapshot } from "./snapshot.js";
+/**
+ * An interface for content that can be painted.
+ *
+ * The content of a `GdkPaintable` can be painted anywhere at any size
+ * without requiring any sort of layout. The interface is inspired by
+ * similar concepts elsewhere, such as
+ * ClutterContent,
+ * [HTML/CSS Paint Sources](https://www.w3.org/TR/css-images-4/#paint-source),
+ * or SVG Paint Servers.
+ *
+ * A `GdkPaintable` can be snapshot at any time and size using
+ * [method@Gdk.Paintable.snapshot]. How the paintable interprets that size and
+ * if it scales or centers itself into the given rectangle is implementation
+ * defined, though if you are implementing a `GdkPaintable` and don't know what
+ * to do, it is suggested that you scale your paintable ignoring any potential
+ * aspect ratio.
+ *
+ * The contents that a `GdkPaintable` produces may depend on the [class@Gdk.Snapshot]
+ * passed to it. For example, paintables may decide to use more detailed images
+ * on higher resolution screens or when OpenGL is available. A `GdkPaintable`
+ * will however always produce the same output for the same snapshot.
+ *
+ * A `GdkPaintable` may change its contents, meaning that it will now produce
+ * a different output with the same snapshot. Once that happens, it will call
+ * [method@Gdk.Paintable.invalidate_contents] which will emit the
+ * [signal@Gdk.Paintable::invalidate-contents] signal. If a paintable is known
+ * to never change its contents, it will set the %GDK_PAINTABLE_STATIC_CONTENTS
+ * flag. If a consumer cannot deal with changing contents, it may call
+ * [method@Gdk.Paintable.get_current_image] which will return a static
+ * paintable and use that.
+ *
+ * A paintable can report an intrinsic (or preferred) size or aspect ratio it
+ * wishes to be rendered at, though it doesn't have to. Consumers of the interface
+ * can use this information to layout thepaintable appropriately. Just like the
+ * contents, the size of a paintable can change. A paintable will indicate this
+ * by calling [method@Gdk.Paintable.invalidate_size] which will emit the
+ * [signal@Gdk.Paintable::invalidate-size] signal. And just like for contents,
+ * if a paintable is known to never change its size, it will set the
+ * %GDK_PAINTABLE_STATIC_SIZE flag.
+ *
+ * Besides API for applications, there are some functions that are only
+ * useful for implementing subclasses and should not be used by applications:
+ * [method@Gdk.Paintable.invalidate_contents],
+ * [method@Gdk.Paintable.invalidate_size],
+ * [func@Gdk.Paintable.new_empty].
+ */
 export declare class Paintable {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Paintable;
+    /**
+     * 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: number, specifiedHeight: number, defaultWidth: number, defaultHeight: number, concreteWidth: Ref<number>, concreteHeight: Ref<number>): void;
+    /**
+     * 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(): Paintable;
+    /**
+     * Get flags for the paintable.
+     *
+     * This is oftentimes useful for optimizations.
+     *
+     * See [flags@Gdk.PaintableFlags] for the flags and what they mean.
+     */
     getFlags(): PaintableFlags;
+    /**
+     * 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: Snapshot, width: number, height: number): void;
 }

package/dist/generated/gdk/paintable.js

@@ -1,5 +1,51 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * An interface for content that can be painted.
+ *
+ * The content of a `GdkPaintable` can be painted anywhere at any size
+ * without requiring any sort of layout. The interface is inspired by
+ * similar concepts elsewhere, such as
+ * ClutterContent,
+ * [HTML/CSS Paint Sources](https://www.w3.org/TR/css-images-4/#paint-source),
+ * or SVG Paint Servers.
+ *
+ * A `GdkPaintable` can be snapshot at any time and size using
+ * [method@Gdk.Paintable.snapshot]. How the paintable interprets that size and
+ * if it scales or centers itself into the given rectangle is implementation
+ * defined, though if you are implementing a `GdkPaintable` and don't know what
+ * to do, it is suggested that you scale your paintable ignoring any potential
+ * aspect ratio.
+ *
+ * The contents that a `GdkPaintable` produces may depend on the [class@Gdk.Snapshot]
+ * passed to it. For example, paintables may decide to use more detailed images
+ * on higher resolution screens or when OpenGL is available. A `GdkPaintable`
+ * will however always produce the same output for the same snapshot.
+ *
+ * A `GdkPaintable` may change its contents, meaning that it will now produce
+ * a different output with the same snapshot. Once that happens, it will call
+ * [method@Gdk.Paintable.invalidate_contents] which will emit the
+ * [signal@Gdk.Paintable::invalidate-contents] signal. If a paintable is known
+ * to never change its contents, it will set the %GDK_PAINTABLE_STATIC_CONTENTS
+ * flag. If a consumer cannot deal with changing contents, it may call
+ * [method@Gdk.Paintable.get_current_image] which will return a static
+ * paintable and use that.
+ *
+ * A paintable can report an intrinsic (or preferred) size or aspect ratio it
+ * wishes to be rendered at, though it doesn't have to. Consumers of the interface
+ * can use this information to layout thepaintable appropriately. Just like the
+ * contents, the size of a paintable can change. A paintable will indicate this
+ * by calling [method@Gdk.Paintable.invalidate_size] which will emit the
+ * [signal@Gdk.Paintable::invalidate-size] signal. And just like for contents,
+ * if a paintable is known to never change its size, it will set the
+ * %GDK_PAINTABLE_STATIC_SIZE flag.
+ *
+ * Besides API for applications, there are some functions that are only
+ * useful for implementing subclasses and should not be used by applications:
+ * [method@Gdk.Paintable.invalidate_contents],
+ * [method@Gdk.Paintable.invalidate_size],
+ * [func@Gdk.Paintable.new_empty].
+ */
 export class Paintable {
     ptr;
     constructor(ptr) {
@@ -8,6 +54,23 @@ export class Paintable {
     static fromPtr(ptr) {
         return new Paintable(ptr);
     }
+    /**
+     * 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", [
             {
@@ -40,6 +103,14 @@ export class Paintable {
             },
         ], { 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", [
             {
@@ -49,6 +120,13 @@ export class Paintable {
         ], { 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", [
             {
@@ -57,6 +135,25 @@ export class Paintable {
             },
         ], { 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", [
             {
@@ -65,6 +162,18 @@ export class Paintable {
             },
         ], { 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", [
             {
@@ -73,6 +182,18 @@ export class Paintable {
             },
         ], { 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", [
             {
@@ -81,6 +202,18 @@ export class Paintable {
             },
         ], { 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", [
             {
@@ -89,6 +222,18 @@ export class Paintable {
             },
         ], { 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", [
             {
@@ -97,6 +242,16 @@ export class Paintable {
             },
         ], { 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", [
             {