@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -18,85 +18,854 @@ import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import * as cairo from "../cairo/index.js";
+/**
+ * Gets the modifier mask.
+ *
+ * The modifier mask determines which modifiers are considered significant
+ * for keyboard accelerators. This includes all keyboard modifiers except
+ * for `GDK_LOCK_MASK`.
+ */
 export declare const acceleratorGetDefaultModMask: () => Gdk.ModifierType;
+/**
+ * Converts an accelerator keyval and modifier mask into a string
+ * which can be used to represent the accelerator to the user.
+ * @param acceleratorKey - accelerator keyval
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export declare const acceleratorGetLabel: (acceleratorKey: number, acceleratorMods: Gdk.ModifierType) => string;
+/**
+ * Converts an accelerator keyval and modifier mask
+ * into a string that can be displayed to the user.
+ *
+ * The string may be translated.
+ *
+ * This function is similar to [func@Gtk.accelerator_get_label],
+ * but handling keycodes. This is only useful for system-level
+ * components, applications should use [func@Gtk.accelerator_get_label]
+ * instead.
+ * @param display - a `GdkDisplay`
+ * @param acceleratorKey - accelerator keyval
+ * @param keycode - accelerator keycode
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export declare const acceleratorGetLabelWithKeycode: (acceleratorKey: number, keycode: number, acceleratorMods: Gdk.ModifierType, display?: Gdk.Display | null) => string;
+/**
+ * Converts an accelerator keyval and modifier mask into a string
+ * that can be parsed by [func@Gtk.accelerator_parse].
+ *
+ * For example, if you pass in `GDK_KEY_q` and `GDK_CONTROL_MASK`,
+ * this function returns `<Control>q`.
+ *
+ * If you need to display accelerators in the user interface,
+ * see [func@Gtk.accelerator_get_label].
+ * @param acceleratorKey - accelerator keyval
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export declare const acceleratorName: (acceleratorKey: number, acceleratorMods: Gdk.ModifierType) => string;
+/**
+ * Converts an accelerator keyval and modifier mask
+ * into a string that can be parsed by [func@Gtk.accelerator_parse_with_keycode].
+ *
+ * This is similar to [func@Gtk.accelerator_name] but handling keycodes.
+ * This is only useful for system-level components, applications
+ * should use [func@Gtk.accelerator_name] instead.
+ * @param display - a `GdkDisplay`
+ * @param acceleratorKey - accelerator keyval
+ * @param keycode - accelerator keycode
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export declare const acceleratorNameWithKeycode: (acceleratorKey: number, keycode: number, acceleratorMods: Gdk.ModifierType, display?: Gdk.Display | null) => string;
+/**
+ * Parses a string representing an accelerator.
+ *
+ * The format looks like “`<Control>a`” or “`<Shift><Alt>F1`”.
+ *
+ * The parser is fairly liberal and allows lower or upper case, and also
+ * abbreviations such as “`<Ctl>`” and “`<Ctrl>`”.
+ *
+ * Key names are parsed using [func@Gdk.keyval_from_name]. For character keys
+ * the name is not the symbol, but the lowercase name, e.g. one would use
+ * “`<Ctrl>minus`” instead of “`<Ctrl>-`”.
+ *
+ * Modifiers are enclosed in angular brackets `<>`, and match the
+ * [flags@Gdk.ModifierType] mask:
+ *
+ * - `<Shift>` for `GDK_SHIFT_MASK`
+ * - `<Ctrl>` for `GDK_CONTROL_MASK`
+ * - `<Alt>` for `GDK_ALT_MASK`
+ * - `<Meta>` for `GDK_META_MASK`
+ * - `<Super>` for `GDK_SUPER_MASK`
+ * - `<Hyper>` for `GDK_HYPER_MASK`
+ *
+ * If the parse operation fails, `accelerator_key` and `accelerator_mods` will
+ * be set to 0 (zero).
+ * @param accelerator - string representing an accelerator
+ * @param acceleratorKey - return location for accelerator keyval
+ * @param acceleratorMods - return location for accelerator
+ */
 export declare const acceleratorParse: (accelerator: string, acceleratorKey?: Ref<number> | null, acceleratorMods?: Ref<Gdk.ModifierType> | null) => boolean;
+/**
+ * Parses a string representing an accelerator.
+ *
+ * This is similar to [func@Gtk.accelerator_parse] but handles keycodes as
+ * well. This is only useful for system-level components, applications should
+ * use [func@Gtk.accelerator_parse] instead.
+ *
+ * If `accelerator_codes` is given and the result stored in it is non-%NULL,
+ * the result must be freed with g_free().
+ *
+ * If a keycode is present in the accelerator and no `accelerator_codes` is given, the parse will fail.
+ *
+ * If the parse fails, @accelerator_key, `accelerator_mods` and
+ * `accelerator_codes` will be set to 0 (zero).
+ * @param accelerator - string representing an accelerator
+ * @param display - the `GdkDisplay` to look up `accelerator_codes` in
+ * @param acceleratorKey - return location for accelerator keyval
+ * @param acceleratorCodes - return location for accelerator keycodes
+ * @param acceleratorMods - return location for accelerator
+ */
 export declare const acceleratorParseWithKeycode: (accelerator: string, display?: Gdk.Display | null, acceleratorKey?: Ref<number> | null, acceleratorCodes?: Ref<number[]> | null, acceleratorMods?: Ref<Gdk.ModifierType> | null) => boolean;
+/**
+ * Determines whether a given keyval and modifier mask constitute
+ * a valid keyboard accelerator.
+ *
+ * For example, the `GDK_KEY_a` keyval plus `GDK_CONTROL_MASK` mask is valid,
+ * and matches the “Ctrl+a” accelerator. But, you can't, for instance, use
+ * the `GDK_KEY_Control_L` keyval as an accelerator.
+ * @param keyval - a GDK keyval
+ * @param modifiers - modifier mask
+ */
 export declare const acceleratorValid: (keyval: number, modifiers: Gdk.ModifierType) => boolean;
+/**
+ * Initializes `value` with the appropriate type for the @property.
+ *
+ * This function is mostly meant for language bindings, in conjunction
+ * with gtk_accessible_update_property_value().
+ * @param property - a `GtkAccessibleProperty`
+ * @param value - an uninitialized `GValue`
+ */
 export declare const accessiblePropertyInitValue: (property: AccessibleProperty, value: GObject.Value) => void;
+/**
+ * Initializes `value` with the appropriate type for the @relation.
+ *
+ * This function is mostly meant for language bindings, in conjunction
+ * with gtk_accessible_update_relation_value().
+ * @param relation - a `GtkAccessibleRelation`
+ * @param value - an uninitialized `GValue`
+ */
 export declare const accessibleRelationInitValue: (relation: AccessibleRelation, value: GObject.Value) => void;
+/**
+ * Initializes `value` with the appropriate type for the @state.
+ *
+ * This function is mostly meant for language bindings, in conjunction
+ * with gtk_accessible_update_relation_state().
+ * @param state - a `GtkAccessibleState`
+ * @param value - an uninitialized `GValue`
+ */
 export declare const accessibleStateInitValue: (state: AccessibleState, value: GObject.Value) => void;
+/**
+ * Initializes `iter` to point to @target.
+ *
+ * If `target` is not found, finds the next value after it.
+ * If no value >= `target` exists in @set, this function returns %FALSE.
+ * @param iter - a pointer to an uninitialized `GtkBitsetIter`
+ * @param set - a `GtkBitset`
+ * @param target - target value to start iterating at
+ * @param value - Set to the found value in @set
+ */
 export declare const bitsetIterInitAt: (iter: Ref<BitsetIter>, set: Bitset, target: number, value?: Ref<number> | null) => boolean;
+/**
+ * Initializes an iterator for `set` and points it to the first
+ * value in @set.
+ *
+ * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
+ * @param iter - a pointer to an uninitialized `GtkBitsetIter`
+ * @param set - a `GtkBitset`
+ * @param value - Set to the first value in @set
+ */
 export declare const bitsetIterInitFirst: (iter: Ref<BitsetIter>, set: Bitset, value?: Ref<number> | null) => boolean;
+/**
+ * Initializes an iterator for `set` and points it to the last
+ * value in @set.
+ *
+ * If `set` is empty, %FALSE is returned.
+ * @param iter - a pointer to an uninitialized `GtkBitsetIter`
+ * @param set - a `GtkBitset`
+ * @param value - Set to the last value in @set
+ */
 export declare const bitsetIterInitLast: (iter: Ref<BitsetIter>, set: Bitset, value?: Ref<number> | null) => boolean;
+/**
+ * Registers an error quark for [class@Gtk.Builder] errors.
+ */
 export declare const builderErrorQuark: () => number;
+/**
+ * Checks that the GTK library in use is compatible with the
+ * given version.
+ *
+ * Generally you would pass in the constants %GTK_MAJOR_VERSION,
+ * %GTK_MINOR_VERSION, %GTK_MICRO_VERSION as the three arguments
+ * to this function; that produces a check that the library in
+ * use is compatible with the version of GTK the application or
+ * module was compiled against.
+ *
+ * Compatibility is defined by two things: first the version
+ * of the running library is newer than the version
+ * @required_major.required_minor.@required_micro. Second
+ * the running library must be binary compatible with the
+ * version @required_major.required_minor.`required_micro` (same major version.)
+ *
+ * This function is primarily for GTK modules; the module
+ * can call this function to check that it wasn’t loaded
+ * into an incompatible version of GTK. However, such a
+ * check isn’t completely reliable, since the module may be
+ * linked against an old version of GTK and calling the
+ * old version of gtk_check_version(), but still get loaded
+ * into an application using a newer version of GTK.
+ * @param requiredMajor - the required major version
+ * @param requiredMinor - the required minor version
+ * @param requiredMicro - the required micro version
+ */
 export declare const checkVersion: (requiredMajor: number, requiredMinor: number, requiredMicro: number) => string | null;
+/**
+ * Registers an error quark for VFL error parsing.
+ */
 export declare const constraintVflParserErrorQuark: () => number;
+/**
+ * Registers an error quark for CSS parsing errors.
+ */
 export declare const cssParserErrorQuark: () => number;
+/**
+ * Registers an error quark for CSS parsing warnings.
+ */
 export declare const cssParserWarningQuark: () => number;
+/**
+ * Registers an error quark for an operation that requires a dialog if
+ * necessary.
+ */
 export declare const dialogErrorQuark: () => number;
+/**
+ * Prevents GTK from using portals.
+ *
+ * This is equivalent to setting `GDK_DEBUG=no-portals` in the environment.
+ *
+ * This should only be used in portal implementations, apps must not call it.
+ */
 export declare const disablePortals: () => void;
+/**
+ * Prevents [func@Gtk.init] and [func@Gtk.init_check] from calling `setlocale()`.
+ *
+ * You would want to use this function if you wanted to set the locale for
+ * your program to something other than the user’s locale, or if you wanted
+ * to set different values for different locale categories.
+ *
+ * Most programs should not need to call this function.
+ */
 export declare const disableSetlocale: () => void;
+/**
+ * Distributes `extra_space` to child `sizes` by bringing smaller
+ * children up to natural size first.
+ *
+ * The remaining space will be added to the `minimum_size` member of the
+ * `GtkRequestedSize` struct. If all sizes reach their natural size then
+ * the remaining space is returned.
+ * @param extraSpace - Extra space to redistribute among children after subtracting
+ * @param nRequestedSizes - Number of requests to fit into the allocation
+ * @param sizes - An array of structs with a client pointer and a minimum/natural size
+ */
 export declare const distributeNaturalAllocation: (extraSpace: number, nRequestedSizes: number, sizes: number[]) => number;
+/**
+ * Gets a property of the `GtkEditable` delegate for @object.
+ *
+ * This is helper function that should be called in the `get_property`
+ * function of your `GtkEditable` implementation, before handling your
+ * own properties.
+ * @param object - a `GObject`
+ * @param propId - a property ID
+ * @param value - value to set
+ * @param pspec - the `GParamSpec` for the property
+ */
 export declare const editableDelegateGetProperty: (object: GObject.GObject, propId: number, value: GObject.Value, pspec: GObject.ParamSpec) => boolean;
+/**
+ * Sets a property on the `GtkEditable` delegate for @object.
+ *
+ * This is a helper function that should be called in the `set_property`
+ * function of your `GtkEditable` implementation, before handling your
+ * own properties.
+ * @param object - a `GObject`
+ * @param propId - a property ID
+ * @param value - value to set
+ * @param pspec - the `GParamSpec` for the property
+ */
 export declare const editableDelegateSetProperty: (object: GObject.GObject, propId: number, value: GObject.Value, pspec: GObject.ParamSpec) => boolean;
+/**
+ * Overrides the `GtkEditable` properties for @class.
+ *
+ * This is a helper function that should be called in class_init,
+ * after installing your own properties.
+ *
+ * Note that your class must have "text", "cursor-position",
+ * "selection-bound", "editable", "width-chars", "max-width-chars",
+ * "xalign" and "enable-undo" properties for this function to work.
+ *
+ * To handle the properties in your set_property and get_property
+ * functions, you can either use [func@Gtk.Editable.delegate_set_property]
+ * and [func@Gtk.Editable.delegate_get_property] (if you are using
+ * a delegate), or remember the `first_prop` offset and add it to the
+ * values in the [enum@Gtk.EditableProperties] enumeration to get the
+ * property IDs for these properties.
+ * @param objectClass - a `GObjectClass`
+ * @param firstProp - property ID to use for the first property
+ */
 export declare const editableInstallProperties: (objectClass: number, firstProp: number) => number;
+/**
+ * Calls a function for all printers that are known to GTK.
+ *
+ * If `func` returns true, the enumeration is stopped.
+ * @param func - a function to call for each printer
+ * @param data - user data to pass to @func
+ * @param destroy - function to call if `data` is no longer needed
+ * @param wait - if true, wait in a recursive mainloop until
+ */
 export declare const enumeratePrinters: (func: (...args: unknown[]) => unknown, destroy: () => void, wait: boolean, data?: number | null) => void;
+/**
+ * Registers an error quark for `GtkFileChooser` errors.
+ */
 export declare const fileChooserErrorQuark: () => number;
+/**
+ * Returns the binary age as passed to `libtool`.
+ *
+ * If `libtool` means nothing to you, don't worry about it.
+ */
 export declare const getBinaryAge: () => number;
+/**
+ * Returns the GTK debug flags that are currently active.
+ *
+ * This function is intended for GTK modules that want
+ * to adjust their debug output based on GTK debug flags.
+ */
 export declare const getDebugFlags: () => DebugFlags;
+/**
+ * Returns the `PangoLanguage` for the default language
+ * currently in effect.
+ *
+ * Note that this can change over the life of an
+ * application.
+ *
+ * The default language is derived from the current
+ * locale. It determines, for example, whether GTK uses
+ * the right-to-left or left-to-right text direction.
+ *
+ * This function is equivalent to [func@Pango.Language.get_default].
+ * See that function for details.
+ */
 export declare const getDefaultLanguage: () => Pango.Language;
+/**
+ * Returns the interface age as passed to `libtool`.
+ *
+ * If `libtool` means nothing to you, don't worry about it.
+ */
 export declare const getInterfaceAge: () => number;
+/**
+ * Gets the direction of the current locale.
+ *
+ * This is the expected reading direction for text and UI.
+ *
+ * This function depends on the current locale being set with
+ * `setlocale()` and will default to setting the `GTK_TEXT_DIR_LTR`
+ * direction otherwise. `GTK_TEXT_DIR_NONE` will never be returned.
+ *
+ * GTK sets the default text direction according to the locale during
+ * [func@Gtk.init], and you should normally use [method@Gtk.Widget.get_direction]
+ * or [func@Gtk.Widget.get_default_direction] to obtain the current direction.
+ *
+ * This function is only needed rare cases when the locale is
+ * changed after GTK has already been initialized. In this case,
+ * you can use it to update the default text direction as follows:
+ *
+ * ```c
+ * #include <locale.h>
+ *
+ * static void
+ * update_locale (const char *new_locale)
+ * {
+ * setlocale (LC_ALL, new_locale);
+ * gtk_widget_set_default_direction (gtk_get_locale_direction ());
+ * }
+ * ```
+ */
 export declare const getLocaleDirection: () => TextDirection;
+/**
+ * Returns the major version number of the GTK library.
+ *
+ * For example, in GTK version 3.1.5 this is 3.
+ *
+ * This function is in the library, so it represents the GTK library
+ * your code is running against. Contrast with the %GTK_MAJOR_VERSION
+ * macro, which represents the major version of the GTK headers you
+ * have included when compiling your code.
+ */
 export declare const getMajorVersion: () => number;
+/**
+ * Returns the micro version number of the GTK library.
+ *
+ * For example, in GTK version 3.1.5 this is 5.
+ *
+ * This function is in the library, so it represents the GTK library
+ * your code is are running against. Contrast with the
+ * %GTK_MICRO_VERSION macro, which represents the micro version of the
+ * GTK headers you have included when compiling your code.
+ */
 export declare const getMicroVersion: () => number;
+/**
+ * Returns the minor version number of the GTK library.
+ *
+ * For example, in GTK version 3.1.5 this is 1.
+ *
+ * This function is in the library, so it represents the GTK library
+ * your code is are running against. Contrast with the
+ * %GTK_MINOR_VERSION macro, which represents the minor version of the
+ * GTK headers you have included when compiling your code.
+ */
 export declare const getMinorVersion: () => number;
+/**
+ * Converts a color from HSV space to RGB.
+ *
+ * Input values must be in the [0.0, 1.0] range;
+ * output values will be in the same range.
+ * @param h - Hue
+ * @param s - Saturation
+ * @param v - Value
+ * @param r - Return value for the red component
+ * @param g - Return value for the green component
+ * @param b - Return value for the blue component
+ */
 export declare const hsvToRgb: (h: number, s: number, v: number, r: Ref<number>, g: Ref<number>, b: Ref<number>) => void;
+/**
+ * Registers an error quark for [class@Gtk.IconTheme] errors.
+ */
 export declare const iconThemeErrorQuark: () => number;
+/**
+ * Initializes GTK.
+ *
+ * This function must be called before using any other GTK functions
+ * in your GUI applications.
+ *
+ * It will initialize everything needed to operate the toolkit. In particular,
+ * it will open the default display (see [func@Gdk.Display.get_default]).
+ *
+ * If you are using [class@Gtk.Application], you usually don't have to call this
+ * function; the [vfunc@Gio.Application.startup] handler does it for you. Though,
+ * if you are using `GApplication` methods that will be invoked before `startup`,
+ * such as `local_command_line`, you may need to initialize GTK explicitly.
+ *
+ * This function will terminate your program if it was unable to initialize
+ * the windowing system for some reason. If you want your program to fall back
+ * to a textual interface, call [func@Gtk.init_check] instead.
+ *
+ * GTK calls `signal (SIGPIPE, SIG_IGN)` during initialization, to ignore
+ * SIGPIPE signals, since these are almost never wanted in graphical
+ * applications. If you do need to handle SIGPIPE for some reason, reset
+ * the handler after gtk_init(), but notice that other libraries (e.g.
+ * libdbus or gvfs) might do similar things.
+ */
 export declare const init: () => void;
+/**
+ * Initializes GTK.
+ *
+ * This function does the same work as [func@Gtk.init] with only a
+ * single change: It does not terminate the program if the windowing
+ * system can’t be initialized. Instead it returns false on failure.
+ *
+ * This way the application can fall back to some other means of
+ * communication with the user - for example a curses or command line
+ * interface.
+ */
 export declare const initCheck: () => boolean;
+/**
+ * Returns whether GTK has been initialized.
+ *
+ * See [func@Gtk.init].
+ */
 export declare const isInitialized: () => boolean;
+/**
+ * Finds the `GtkNative` associated with the surface.
+ * @param surface - a `GdkSurface`
+ */
 export declare const nativeGetForSurface: (surface: Gdk.Surface) => Native | null;
+/**
+ * Returns the name of the default paper size, which
+ * depends on the current locale.
+ */
 export declare const paperSizeGetDefault: () => string;
+/**
+ * Creates a list of known paper sizes.
+ * @param includeCustom - whether to include custom paper sizes
+ */
 export declare const paperSizeGetPaperSizes: (includeCustom: boolean) => PaperSize[];
+/**
+ * Creates a new `GParamSpec` instance for a property holding a `GtkExpression`.
+ *
+ * See `g_param_spec_internal()` for details on the property strings.
+ * @param name - canonical name of the property
+ * @param nick - a user-readable name for the property
+ * @param blurb - a user-readable description of the property
+ * @param flags - flags for the property
+ */
 export declare const paramSpecExpression: (name: string, nick: string, blurb: string, flags: GObject.ParamFlags) => GObject.ParamSpec;
+/**
+ * Registers an error quark for `GtkPrintOperation` if necessary.
+ */
 export declare const printErrorQuark: () => number;
+/**
+ * Runs a page setup dialog, letting the user modify the values from @page_setup.
+ *
+ * If the user cancels the dialog, the returned `GtkPageSetup` is identical
+ * to the passed in @page_setup, otherwise it contains the modifications
+ * done in the dialog.
+ *
+ * Note that this function may use a recursive mainloop to show the page
+ * setup dialog. See [func@Gtk.print_run_page_setup_dialog_async] if this is
+ * a problem.
+ * @param parent - transient parent
+ * @param pageSetup - an existing `GtkPageSetup`
+ * @param settings - a `GtkPrintSettings`
+ */
 export declare const printRunPageSetupDialog: (settings: PrintSettings, parent?: Window | null, pageSetup?: PageSetup | null) => PageSetup;
+/**
+ * Runs a page setup dialog, letting the user modify the values from @page_setup.
+ *
+ * In contrast to [func@Gtk.print_run_page_setup_dialog], this function  returns
+ * after showing the page setup dialog on platforms that support this, and calls
+ * `done_cb` from a signal handler for the ::response signal of the dialog.
+ * @param parent - transient parent
+ * @param pageSetup - an existing `GtkPageSetup`
+ * @param settings - a `GtkPrintSettings`
+ * @param doneCb - a function to call when the user saves
+ * @param data - user data to pass to @done_cb
+ */
 export declare const printRunPageSetupDialogAsync: (settings: PrintSettings, doneCb: (...args: unknown[]) => unknown, parent?: Window | null, pageSetup?: PageSetup | null, data?: number | null) => void;
+/**
+ * Registers an error quark for [class@RecentManager] errors.
+ */
 export declare const recentManagerErrorQuark: () => number;
+/**
+ * Renders an activity indicator (such as in `GtkSpinner`).
+ * The state %GTK_STATE_FLAG_CHECKED determines whether there is
+ * activity going on.
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderActivity: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Renders an arrow pointing to @angle.
+ *
+ * Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param angle - arrow angle from 0 to 2 * %G_PI, being 0 the arrow pointing to the north
+ * @param x - X origin of the render area
+ * @param y - Y origin of the render area
+ * @param size - square side for render area
+ */
 export declare const renderArrow: (context: StyleContext, cr: cairo.Context, angle: number, x: number, y: number, size: number) => void;
+/**
+ * Renders the background of an element.
+ *
+ * Typical background rendering, showing the effect of
+ * `background-image`, `border-width` and `border-radius`:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderBackground: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Renders a checkmark (as in a `GtkCheckButton`).
+ *
+ * The %GTK_STATE_FLAG_CHECKED state determines whether the check is
+ * on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it
+ * should be marked as undefined.
+ *
+ * Typical checkmark rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderCheck: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Renders an expander (as used in `GtkTreeView` and `GtkExpander`) in the area
+ * defined by @x, @y, @width, @height. The state %GTK_STATE_FLAG_CHECKED
+ * determines whether the expander is collapsed or expanded.
+ *
+ * Typical expander rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderExpander: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Renders a focus indicator on the rectangle determined by @x, @y, @width, @height.
+ *
+ * Typical focus rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderFocus: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Renders a frame around the rectangle defined by @x, @y, @width, @height.
+ *
+ * Examples of frame rendering, showing the effect of `border-image`,
+ * `border-color`, `border-width`, `border-radius` and junctions:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderFrame: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Renders a handle (as in `GtkPaned` and `GtkWindow`’s resize grip),
+ * in the rectangle determined by @x, @y, @width, @height.
+ *
+ * Handles rendered for the paned and grip classes:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderHandle: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Renders the icon in `texture` at the specified `x` and `y` coordinates.
+ *
+ * This function will render the icon in `texture` at exactly its size,
+ * regardless of scaling factors, which may not be appropriate when
+ * drawing on displays with high pixel densities.
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param texture - a `GdkTexture` containing the icon to draw
+ * @param x - X position for the @texture
+ * @param y - Y position for the @texture
+ */
 export declare const renderIcon: (context: StyleContext, cr: cairo.Context, texture: Gdk.Texture, x: number, y: number) => void;
+/**
+ * Renders `layout` on the coordinates @x, @y
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin
+ * @param y - Y origin
+ * @param layout - the `PangoLayout` to render
+ */
 export declare const renderLayout: (context: StyleContext, cr: cairo.Context, x: number, y: number, layout: Pango.Layout) => void;
+/**
+ * Renders a line from (x0, y0) to (x1, y1).
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x0 - X coordinate for the origin of the line
+ * @param y0 - Y coordinate for the origin of the line
+ * @param x1 - X coordinate for the end of the line
+ * @param y1 - Y coordinate for the end of the line
+ */
 export declare const renderLine: (context: StyleContext, cr: cairo.Context, x0: number, y0: number, x1: number, y1: number) => void;
+/**
+ * Renders an option mark (as in a radio button), the %GTK_STATE_FLAG_CHECKED
+ * state will determine whether the option is on or off, and
+ * %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.
+ *
+ * Typical option mark rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export declare const renderOption: (context: StyleContext, cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Converts a color from RGB space to HSV.
+ *
+ * Input values must be in the [0.0, 1.0] range;
+ * output values will be in the same range.
+ * @param r - Red
+ * @param g - Green
+ * @param b - Blue
+ * @param h - Return value for the hue component
+ * @param s - Return value for the saturation component
+ * @param v - Return value for the value component
+ */
 export declare const rgbToHsv: (r: number, g: number, b: number, h: Ref<number>, s: Ref<number>, v: Ref<number>) => void;
+/**
+ * Sets the GTK debug flags.
+ * @param flags - the debug flags to set
+ */
 export declare const setDebugFlags: (flags: DebugFlags) => void;
+/**
+ * This function launches the default application for showing
+ * a given uri, or shows an error dialog if that fails.
+ * @param parent - parent window
+ * @param uri - the uri to show
+ * @param timestamp - timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+ */
 export declare const showUri: (uri: string, timestamp: number, parent?: Window | null) => void;
+/**
+ * This function launches the default application for showing
+ * a given uri.
+ *
+ * The `callback` will be called when the launch is completed.
+ *
+ * This is the recommended call to be used as it passes information
+ * necessary for sandbox helpers to parent their dialogs properly.
+ * @param parent - parent window
+ * @param uri - the uri to show
+ * @param timestamp - timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+ * @param cancellable - a `GCancellable` to cancel the launch
+ * @param callback - a callback to call when the action is complete
+ * @param userData - data to pass to @callback
+ */
 export declare const showUriFull: (uri: string, timestamp: number, parent?: Window | null, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null) => void;
+/**
+ * Finishes the gtk_show_uri() call and returns the result
+ * of the operation.
+ * @param parent - the `GtkWindow` passed to gtk_show_uri()
+ * @param result - `GAsyncResult` that was passed to @callback
+ */
 export declare const showUriFullFinish: (parent: Window, result: Gio.AsyncResult) => boolean;
+/**
+ * Prints an assertion message for gtk_test_accessible_assert_role().
+ * @param domain - a domain
+ * @param file - a file name
+ * @param line - the line in @file
+ * @param func - a function name in @file
+ * @param expr - the expression being tested
+ * @param accessible - a `GtkAccessible`
+ * @param expectedRole - the expected `GtkAccessibleRole`
+ * @param actualRole - the actual `GtkAccessibleRole`
+ */
 export declare const testAccessibleAssertionMessageRole: (domain: string, file: string, line: number, func: string, expr: string, accessible: Accessible, expectedRole: AccessibleRole, actualRole: AccessibleRole) => void;
+/**
+ * Checks whether the `GtkAccessible` has `property` set.
+ * @param accessible - a `GtkAccessible`
+ * @param property - a `GtkAccessibleProperty`
+ */
 export declare const testAccessibleHasProperty: (accessible: Accessible, property: AccessibleProperty) => boolean;
+/**
+ * Checks whether the `GtkAccessible` has `relation` set.
+ * @param accessible - a `GtkAccessible`
+ * @param relation - a `GtkAccessibleRelation`
+ */
 export declare const testAccessibleHasRelation: (accessible: Accessible, relation: AccessibleRelation) => boolean;
+/**
+ * Checks whether the `GtkAccessible:accessible-role` of the accessible
+ * is @role.
+ * @param accessible - a `GtkAccessible`
+ * @param role - a `GtkAccessibleRole`
+ */
 export declare const testAccessibleHasRole: (accessible: Accessible, role: AccessibleRole) => boolean;
+/**
+ * Checks whether the `GtkAccessible` has `state` set.
+ * @param accessible - a `GtkAccessible`
+ * @param state - a `GtkAccessibleState`
+ */
 export declare const testAccessibleHasState: (accessible: Accessible, state: AccessibleState) => boolean;
+/**
+ * Return the type ids that have been registered after
+ * calling gtk_test_register_all_types().
+ * @param nTypes - location to store number of types
+ */
 export declare const testListAllTypes: (nTypes: Ref<number>) => number[];
+/**
+ * Force registration of all core GTK object types.
+ *
+ * This allows to refer to any of those object types via
+ * g_type_from_name() after calling this function.
+ */
 export declare const testRegisterAllTypes: () => void;
+/**
+ * Enters the main loop and waits for `widget` to be “drawn”.
+ *
+ * In this context that means it waits for the frame clock of
+ * `widget` to have run a full styling, layout and drawing cycle.
+ *
+ * This function is intended to be used for syncing with actions that
+ * depend on `widget` relayouting or on interaction with the display
+ * server.
+ * @param widget - the widget to wait for
+ */
 export declare const testWidgetWaitForDraw: (widget: Widget) => void;
+/**
+ * Creates a content provider for dragging `path` from @tree_model.
+ * @param treeModel - a `GtkTreeModel`
+ * @param path - a row in @tree_model
+ */
 export declare const treeCreateRowDragContent: (treeModel: TreeModel, path: TreePath) => Gdk.ContentProvider;
+/**
+ * Obtains a `tree_model` and `path` from value of target type
+ * %GTK_TYPE_TREE_ROW_DATA.
+ *
+ * The returned path must be freed with gtk_tree_path_free().
+ * @param value - a `GValue`
+ * @param treeModel - a `GtkTreeModel`
+ * @param path - row in @tree_model
+ */
 export declare const treeGetRowDragData: (value: GObject.Value, treeModel?: Ref<TreeModel> | null, path?: Ref<TreePath> | null) => boolean;
+/**
+ * Lets a set of row reference created by
+ * gtk_tree_row_reference_new_proxy() know that the
+ * model emitted the ::row-deleted signal.
+ * @param proxy - a `GObject`
+ * @param path - the path position that was deleted
+ */
 export declare const treeRowReferenceDeleted: (proxy: GObject.GObject, path: TreePath) => void;
+/**
+ * Lets a set of row reference created by
+ * gtk_tree_row_reference_new_proxy() know that the
+ * model emitted the ::row-inserted signal.
+ * @param proxy - a `GObject`
+ * @param path - the row position that was inserted
+ */
 export declare const treeRowReferenceInserted: (proxy: GObject.GObject, path: TreePath) => void;
+/**
+ * Retrieves the `GtkExpression` stored inside the given `value`, and acquires
+ * a reference to it.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ */
 export declare const valueDupExpression: (value: GObject.Value) => Expression | null;
+/**
+ * Retrieves the `GtkExpression` stored inside the given `value`.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ */
 export declare const valueGetExpression: (value: GObject.Value) => Expression | null;
+/**
+ * Stores the given `GtkExpression` inside `value`.
+ *
+ * The `GValue` will acquire a reference to the `expression`.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ * @param expression - a `GtkExpression`
+ */
 export declare const valueSetExpression: (value: GObject.Value, expression: Expression) => void;
+/**
+ * Stores the given `GtkExpression` inside `value`.
+ *
+ * This function transfers the ownership of the `expression` to the `GValue`.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ * @param expression - a `GtkExpression`
+ */
 export declare const valueTakeExpression: (value: GObject.Value, expression?: Expression | null) => void;