@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -22,188 +22,1929 @@ import * as cairo from "../cairo/index.js";
 export declare class Widget extends GObject.InitiallyUnowned {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Obtains the default reading direction.
+     *
+     * See [func@Gtk.Widget.set_default_direction].
+     */
     static getDefaultDirection(): TextDirection;
+    /**
+     * Sets the default reading direction for widgets.
+     *
+     * See [method@Gtk.Widget.set_direction].
+     * @param dir - the new default direction, either [enum@Gtk.TextDirection.ltr]
+     */
     static setDefaultDirection(dir: TextDirection): void;
+    /**
+     * Enables or disables an action installed with
+     * [method@Gtk.WidgetClass.install_action].
+     * @param actionName - action name, such as "clipboard.paste"
+     * @param enabled - whether the action is now enabled
+     */
     actionSetEnabled(actionName: string, enabled: boolean): void;
+    /**
+     * Activates the widget.
+     *
+     * The activation will emit the signal set using
+     * [method@Gtk.WidgetClass.set_activate_signal]
+     * during class initialization.
+     *
+     * Activation is what happens when you press `Enter`
+     * on a widget.
+     *
+     * If you wish to handle the activation keybinding yourself,
+     * it is recommended to use [method@Gtk.WidgetClass.add_shortcut]
+     * with an action created with [ctor@Gtk.SignalAction.new].
+     *
+     * If `widget` is not activatable, the function returns false.
+     */
     activate(): boolean;
+    /**
+     * Activates an action for the widget.
+     *
+     * The action is looked up in the action groups associated with
+     * `widget` and its ancestors.
+     *
+     * If the action is in an action group added with
+     * [method@Gtk.Widget.insert_action_group], the `name` is expected
+     * to be prefixed with the prefix that was used when the group was
+     * inserted.
+     *
+     * The arguments must match the actions expected parameter type,
+     * as returned by [method@Gio.Action.get_parameter_type].
+     * @param name - the name of the action to activate
+     * @param args - parameters to use
+     */
     activateActionVariant(name: string, args?: GLib.Variant | null): boolean;
+    /**
+     * Activates the `default.activate` action for the widget.
+     *
+     * The action is looked up in the same was as for
+     * [method@Gtk.Widget.activate_action].
+     */
     activateDefault(): void;
+    /**
+     * Adds an event controller to the widget.
+     *
+     * The event controllers of a widget handle the events that are
+     * propagated to the widget.
+     *
+     * You will usually want to call this function right after
+     * creating any kind of [class@Gtk.EventController].
+     * @param controller - an event controller that hasn't been
+     */
     addController(controller: EventController): void;
+    /**
+     * Adds a style class to the widget.
+     *
+     * After calling this function, the widget’s style will match
+     * for @css_class, according to CSS matching rules.
+     *
+     * Use [method@Gtk.Widget.remove_css_class] to remove the
+     * style again.
+     * @param cssClass - style class to add to @widget, without the leading period
+     */
     addCssClass(cssClass: string): void;
+    /**
+     * Adds a widget to the list of mnemonic labels for this widget.
+     *
+     * See [method@Gtk.Widget.list_mnemonic_labels].
+     *
+     * Note that the list of mnemonic labels for the widget is cleared
+     * when the widget is destroyed, so the caller must make sure
+     * to update its internal state at this point as well.
+     * @param label - a widget that acts as a mnemonic label for @widget
+     */
     addMnemonicLabel(label: Widget): void;
+    /**
+     * Queues an animation frame update and adds a callback to be called
+     * before each frame.
+     *
+     * Until the tick callback is removed, it will be called frequently
+     * (usually at the frame rate of the output device or as quickly as
+     * the application can be repainted, whichever is slower). For this
+     * reason, is most suitable for handling graphics that change every
+     * frame or every few frames.
+     *
+     * The tick callback does not automatically imply a relayout or repaint.
+     * If you want a repaint or relayout, and aren’t changing widget properties
+     * that would trigger that (for example, changing the text of a label),
+     * then you will have to call [method@Gtk.Widget.queue_resize] or
+     * [method@Gtk.Widget.queue_draw] yourself.
+     *
+     * [method@Gdk.FrameClock.get_frame_time] should generally be used
+     * for timing continuous animations and
+     * [method@Gdk.FrameTimings.get_predicted_presentation_time] should be
+     * used if you are trying to display isolated frames at particular times.
+     *
+     * This is a more convenient alternative to connecting directly to the
+     * [signal@Gdk.FrameClock::update] signal of the frame clock, since you
+     * don't have to worry about when a frame clock is assigned to a widget.
+     *
+     * To remove a tick callback, pass the ID that is returned by this function
+     * to [method@Gtk.Widget.remove_tick_callback].
+     * @param callback - function
+     * @param userData - data to pass to @callback
+     * @param notify - function to call to free @user_data
+     */
     addTickCallback(callback: (...args: unknown[]) => unknown, notify: () => void, userData?: number | null): number;
+    /**
+     * Assigns size, position, (optionally) a baseline and transform
+     * to a child widget.
+     *
+     * In this function, the allocation and baseline may be adjusted.
+     * The given allocation will be forced to be bigger than the
+     * widget's minimum size, as well as at least 0×0 in size.
+     *
+     * This function is only used by widget implementations.
+     *
+     * For a version that does not take a transform, see
+     * [method@Gtk.Widget.size_allocate].
+     * @param width - new width
+     * @param height - new height
+     * @param baseline - new baseline, or -1
+     * @param transform - transformation to be applied
+     */
     allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+    /**
+     * Called by widgets as the user moves around the window using
+     * keyboard shortcuts.
+     *
+     * The `direction` argument indicates what kind of motion is taking
+     * place (up, down, left, right, tab forward, tab backward).
+     *
+     * This function calls the [vfunc@Gtk.Widget.focus] virtual function;
+     * widgets can override the virtual function in order to implement
+     * appropriate focus behavior.
+     *
+     * The default `focus()` virtual function for a widget should return
+     * true if moving in `direction` left the focus on a focusable location
+     * inside that widget, and false if moving in `direction` moved the focus
+     * outside the widget. When returning true, widgets normally call
+     * [method@Gtk.Widget.grab_focus] to place the focus accordingly;
+     * when returning false, they don’t modify the current focus location.
+     *
+     * This function is used by custom widget implementations; if you're
+     * writing an app, you’d use [method@Gtk.Widget.grab_focus] to move
+     * the focus to a particular widget.
+     * @param direction - direction of focus movement
+     */
     childFocus(direction: DirectionType): boolean;
+    /**
+     * Computes the bounds for `widget` in the coordinate space of @target.
+     *
+     * The bounds of widget are (the bounding box of) the region that it is
+     * expected to draw in. See the coordinate system
+     * overview to learn more.
+     *
+     * If the operation is successful, true is returned. If `widget` has no
+     * bounds or the bounds cannot be expressed in @target's coordinate space
+     * (for example if both widgets are in different windows), false is
+     * returned and `bounds` is set to the zero rectangle.
+     *
+     * It is valid for `widget` and `target` to be the same widget.
+     * @param target - the target widget
+     * @param outBounds - the rectangle taking the bounds
+     */
     computeBounds(target: Widget, outBounds: Ref<Graphene.Rect>): boolean;
+    /**
+     * Computes whether a parent widget should give this widget
+     * extra space when possible.
+     *
+     * Widgets with children should check this, rather than looking at
+     * [method@Gtk.Widget.get_hexpand] or [method@Gtk.Widget.get_vexpand].
+     *
+     * This function already checks whether the widget is visible, so
+     * visibility does not need to be checked separately. Non-visible
+     * widgets are not expanded.
+     *
+     * The computed expand value uses either the expand setting explicitly
+     * set on the widget itself, or, if none has been explicitly set,
+     * the widget may expand if some of its children do.
+     * @param orientation - expand direction
+     */
     computeExpand(orientation: Orientation): boolean;
+    /**
+     * Translates the given `point` in @widget's coordinates to coordinates
+     * in @target’s coordinate system.
+     *
+     * In order to perform this operation, both widgets must share a
+     * a common ancestor. If that is not the case, `out_point` is set
+     * to (0, 0) and false is returned.
+     * @param target - the widget to transform into
+     * @param point - a point in @widget's coordinate system
+     * @param outPoint - set to the corresponding coordinates in
+     */
     computePoint(target: Widget, point: Graphene.Point, outPoint: Ref<Graphene.Point>): boolean;
+    /**
+     * Computes a matrix suitable to describe a transformation from
+     * @widget's coordinate system into @target's coordinate system.
+     *
+     * The transform can not be computed in certain cases, for example
+     * when `widget` and `target` do not share a common ancestor. In that
+     * case `out_transform` gets set to the identity matrix.
+     *
+     * To learn more about widget coordinate systems, see the coordinate
+     * system overview.
+     * @param target - the target widget that the matrix will transform to
+     * @param outTransform - location to
+     */
     computeTransform(target: Widget, outTransform: Ref<Graphene.Matrix>): boolean;
+    /**
+     * Tests if a given point is contained in the widget.
+     *
+     * The coordinates for (x, y) must be in widget coordinates, so
+     * (0, 0) is assumed to be the top left of @widget's content area.
+     * @param x - X coordinate to test, relative to @widget's origin
+     * @param y - Y coordinate to test, relative to @widget's origin
+     */
     contains(x: number, y: number): boolean;
+    /**
+     * Creates a new `PangoContext` that is configured for the widget.
+     *
+     * The `PangoContext` will have the appropriate font map,
+     * font options, font description, and base direction set.
+     *
+     * See also [method@Gtk.Widget.get_pango_context].
+     */
     createPangoContext(): Pango.Context;
+    /**
+     * Creates a new `PangoLayout` that is configured for the widget.
+     *
+     * The `PangoLayout` will have the appropriate font map,
+     * font description, and base direction set.
+     *
+     * If you keep a `PangoLayout` created in this way around,
+     * you need to re-create it when the widgets `PangoContext`
+     * is replaced. This can be tracked by listening to changes
+     * of the [property@Gtk.Widget:root] property on the widget.
+     * @param text - text to set on the layout
+     */
     createPangoLayout(text?: string | null): Pango.Layout;
+    /**
+     * Clears the template children for the widget.
+     *
+     * This function is the opposite of [method@Gtk.Widget.init_template],
+     * and it is used to clear all the template children from a widget
+     * instance. If you bound a template child to a field in the instance
+     * structure, or in the instance private data structure, the field will
+     * be set to `NULL` after this function returns.
+     *
+     * You should call this function inside the `GObjectClass.dispose()`
+     * implementation of any widget that called [method@Gtk.Widget.init_template].
+     * Typically, you will want to call this function last, right before
+     * chaining up to the parent type's dispose implementation, e.g.
+     *
+     * ```c
+     * static void
+     * some_widget_dispose (GObject *gobject)
+     * {
+     * SomeWidget *self = SOME_WIDGET (gobject);
+     *
+     * // Clear the template data for SomeWidget
+     * gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+     *
+     * G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+     * }
+     * ```
+     * @param widgetType - the type of the widget to finalize the template for
+     */
     disposeTemplate(widgetType: number): void;
+    /**
+     * Checks to see if a drag movement has passed the GTK drag threshold.
+     * @param startX - X coordinate of start of drag
+     * @param startY - Y coordinate of start of drag
+     * @param currentX - current X coordinate
+     * @param currentY - current Y coordinate
+     */
     dragCheckThreshold(startX: number, startY: number, currentX: number, currentY: number): boolean;
+    /**
+     * Notifies the user about an input-related error on the widget.
+     *
+     * If the [property@Gtk.Settings:gtk-error-bell] setting is true,
+     * it calls [method@Gdk.Surface.beep], otherwise it does nothing.
+     *
+     * Note that the effect of [method@Gdk.Surface.beep] can be configured
+     * in many ways, depending on the windowing backend and the desktop
+     * environment or window manager that is used.
+     */
     errorBell(): void;
+    /**
+     * Returns the baseline that has currently been allocated to the widget.
+     *
+     * This function is intended to be used when implementing handlers
+     * for the `GtkWidget`Class.snapshot() function, and when allocating
+     * child widgets in `GtkWidget`Class.size_allocate().
+     */
     getAllocatedBaseline(): number;
+    /**
+     * Returns the height that has currently been allocated to the widget.
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getAllocatedHeight(): number;
+    /**
+     * Returns the width that has currently been allocated to the widget.
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getAllocatedWidth(): number;
+    /**
+     * Retrieves the widget’s allocation.
+     *
+     * Note, when implementing a layout widget: a widget’s allocation
+     * will be its “adjusted” allocation, that is, the widget’s parent
+     * typically calls [method@Gtk.Widget.size_allocate] with an allocation,
+     * and that allocation is then adjusted (to handle margin
+     * and alignment for example) before assignment to the widget.
+     * [method@Gtk.Widget.get_allocation] returns the adjusted allocation that
+     * was actually assigned to the widget. The adjusted allocation is
+     * guaranteed to be completely contained within the
+     * [method@Gtk.Widget.size_allocate] allocation, however.
+     *
+     * So a layout widget is guaranteed that its children stay inside
+     * the assigned bounds, but not that they have exactly the bounds the
+     * widget assigned.
+     * @param allocation - a pointer to a `GtkAllocation` to copy to
+     */
     getAllocation(allocation: Ref<number>): void;
+    /**
+     * Gets the first ancestor of the widget with type @widget_type.
+     *
+     * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+     * gets the first `GtkBox` that’s an ancestor of @widget. No
+     * reference will be added to the returned widget; it should
+     * not be unreferenced.
+     *
+     * Note that unlike [method@Gtk.Widget.is_ancestor], this function
+     * considers `widget` to be an ancestor of itself.
+     * @param widgetType - ancestor type
+     */
     getAncestor(widgetType: number): Widget | null;
+    /**
+     * Returns the baseline that has currently been allocated to the widget.
+     *
+     * This function is intended to be used when implementing handlers
+     * for the `GtkWidgetClass.snapshot()` function, and when allocating
+     * child widgets in `GtkWidgetClass.size_allocate()`.
+     */
     getBaseline(): number;
+    /**
+     * Determines whether the input focus can enter the widget or any
+     * of its children.
+     *
+     * See [method@Gtk.Widget.set_can_focus].
+     */
     getCanFocus(): boolean;
+    /**
+     * Queries whether the widget can be the target of pointer events.
+     */
     getCanTarget(): boolean;
+    /**
+     * Gets the value set with [method@Gtk.Widget.set_child_visible].
+     *
+     * If you feel a need to use this function, your code probably
+     * needs reorganization.
+     *
+     * This function is only useful for widget implementations
+     * and should never be called by an application.
+     */
     getChildVisible(): boolean;
+    /**
+     * Gets the clipboard object for the widget.
+     *
+     * This is a utility function to get the clipboard object for the
+     * display that `widget` is using.
+     *
+     * Note that this function always works, even when `widget` is not
+     * realized yet.
+     */
     getClipboard(): Gdk.Clipboard;
+    /**
+     * Gets the current foreground color for the widget’s style.
+     *
+     * This function should only be used in snapshot
+     * implementations that need to do custom drawing
+     * with the foreground color.
+     * @param color - return location for the color
+     */
     getColor(color: Ref<Gdk.RGBA>): void;
+    /**
+     * Returns the list of style classes applied to the widget.
+     */
     getCssClasses(): string[];
+    /**
+     * Returns the CSS name of the widget.
+     */
     getCssName(): string;
+    /**
+     * Gets the cursor set on the widget.
+     *
+     * See [method@Gtk.Widget.set_cursor] for details.
+     */
     getCursor(): Gdk.Cursor | null;
+    /**
+     * Gets the reading direction for the widget.
+     *
+     * See [method@Gtk.Widget.set_direction].
+     */
     getDirection(): TextDirection;
+    /**
+     * Get the display for the window that the widget belongs to.
+     *
+     * This function can only be called after the widget has been
+     * added to a widget hierarchy with a `GtkRoot` at the top.
+     *
+     * In general, you should only create display-specific
+     * resources when a widget has been realized, and you should
+     * free those resources when the widget is unrealized.
+     */
     getDisplay(): Gdk.Display;
+    /**
+     * Returns the widget’s first child.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getFirstChild(): Widget | null;
+    /**
+     * Returns the focus child of the widget.
+     */
     getFocusChild(): Widget | null;
+    /**
+     * Returns whether the widget should grab focus when it is clicked
+     * with the mouse.
+     *
+     * See [method@Gtk.Widget.set_focus_on_click].
+     */
     getFocusOnClick(): boolean;
+    /**
+     * Determines whether the widget can own the input focus.
+     *
+     * See [method@Gtk.Widget.set_focusable].
+     */
     getFocusable(): boolean;
+    /**
+     * Gets the font map of the widget.
+     *
+     * See [method@Gtk.Widget.set_font_map].
+     */
     getFontMap(): Pango.FontMap | null;
+    /**
+     * Returns the `cairo_font_options_t` of the widget.
+     *
+     * Seee [method@Gtk.Widget.set_font_options].
+     */
     getFontOptions(): cairo.FontOptions | null;
+    /**
+     * Obtains the frame clock for a widget.
+     *
+     * The frame clock is a global “ticker” that can be used to drive
+     * animations and repaints. The most common reason to get the frame
+     * clock is to call [method@Gdk.FrameClock.get_frame_time], in order
+     * to get a time to use for animating. For example you might record
+     * the start of the animation with an initial value from
+     * [method@Gdk.FrameClock.get_frame_time], and then update the animation
+     * by calling [method@Gdk.FrameClock.get_frame_time] again during each repaint.
+     *
+     * [method@Gdk.FrameClock.request_phase] will result in a new frame on the
+     * clock, but won’t necessarily repaint any widgets. To repaint a widget,
+     * you have to use [method@Gtk.Widget.queue_draw] which invalidates the
+     * widget (thus scheduling it to receive a draw on the next frame).
+     * [method@Gtk.Widget.queue_draw] will also end up requesting a frame
+     * on the appropriate frame clock.
+     *
+     * A widget’s frame clock will not change while the widget is mapped.
+     * Reparenting a widget (which implies a temporary unmap) can change
+     * the widget’s frame clock.
+     *
+     * Unrealized widgets do not have a frame clock.
+     */
     getFrameClock(): Gdk.FrameClock | null;
+    /**
+     * Gets the horizontal alignment of the widget.
+     *
+     * For backwards compatibility reasons this method will never return
+     * one of the baseline alignments, but instead it will convert it to
+     * [enum@Gtk.Align.fill] or [enum@Gtk.Align.center].
+     *
+     * Baselines are not supported for horizontal alignment.
+     */
     getHalign(): Align;
+    /**
+     * Returns the current value of the `has-tooltip` property.
+     */
     getHasTooltip(): boolean;
+    /**
+     * Returns the content height of the widget.
+     *
+     * This function returns the height passed to its
+     * size-allocate implementation, which is the height you
+     * should be using in [vfunc@Gtk.Widget.snapshot].
+     *
+     * For pointer events, see [method@Gtk.Widget.contains].
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getHeight(): number;
+    /**
+     * Gets whether the widget would like any available extra horizontal
+     * space.
+     *
+     * When a user resizes a window, widgets with expand set to true generally
+     * receive the extra space. For example, a list or scrollable area
+     * or document in your window would often be set to expand.
+     *
+     * Widgets with children should use [method@Gtk.Widget.compute_expand]
+     * rather than this function, to see whether any of its children,
+     * has the expand flag set. If any child of a widget wants to
+     * expand, the parent may ask to expand also.
+     *
+     * This function only looks at the widget’s own hexpand flag, rather
+     * than computing whether the entire widget tree rooted at this widget
+     * wants to expand.
+     */
     getHexpand(): boolean;
+    /**
+     * Gets whether the `hexpand` flag has been explicitly set.
+     *
+     * If [property@Gtk.Widget:hexpand] property is set, then it
+     * overrides any computed expand value based on child widgets.
+     * If `hexpand` is not set, then the expand value depends on
+     * whether any children of the widget would like to expand.
+     *
+     * There are few reasons to use this function, but it’s here
+     * for completeness and consistency.
+     */
     getHexpandSet(): boolean;
+    /**
+     * Returns the widget’s last child.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getLastChild(): Widget | null;
+    /**
+     * Retrieves the layout manager of the widget.
+     *
+     * See [method@Gtk.Widget.set_layout_manager].
+     */
     getLayoutManager(): LayoutManager | null;
+    /**
+     * Gets the value of the [property@Gtk.Widget:limit-events] property.
+     */
     getLimitEvents(): boolean;
+    /**
+     * Returns whether the widget is mapped.
+     */
     getMapped(): boolean;
+    /**
+     * Gets the bottom margin of the widget.
+     */
     getMarginBottom(): number;
+    /**
+     * Gets the end margin of the widget.
+     */
     getMarginEnd(): number;
+    /**
+     * Gets the start margin of the widget.
+     */
     getMarginStart(): number;
+    /**
+     * Gets the top margin of the widget.
+     */
     getMarginTop(): number;
+    /**
+     * Retrieves the name of a widget.
+     *
+     * See [method@Gtk.Widget.set_name] for the significance of widget names.
+     */
     getName(): string;
+    /**
+     * Returns the nearest `GtkNative` ancestor of the widget.
+     *
+     * This function will return `NULL` if the widget is not
+     * contained inside a widget tree with a native ancestor.
+     *
+     * `GtkNative` widgets will return themselves here.
+     */
     getNative(): Native | null;
+    /**
+     * Returns the widget’s next sibling.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getNextSibling(): Widget | null;
+    /**
+     * Fetches the requested opacity for the widget.
+     *
+     * See [method@Gtk.Widget.set_opacity].
+     */
     getOpacity(): number;
+    /**
+     * Returns the widget’s overflow value.
+     */
     getOverflow(): Overflow;
+    /**
+     * Gets a `PangoContext` that is configured for the widget.
+     *
+     * The `PangoContext` will have the appropriate font map, font description,
+     * and base direction set.
+     *
+     * Unlike the context returned by [method@Gtk.Widget.create_pango_context],
+     * this context is owned by the widget (it can be used until the screen
+     * for the widget changes or the widget is removed from its toplevel),
+     * and will be updated to match any changes to the widget’s attributes.
+     * This can be tracked by listening to changes of the
+     * [property@Gtk.Widget:root] property on the widget.
+     */
     getPangoContext(): Pango.Context;
+    /**
+     * Returns the parent widget of the widget.
+     */
     getParent(): Widget | null;
+    /**
+     * Retrieves the minimum and natural size of a widget, taking
+     * into account the widget’s preference for height-for-width management.
+     *
+     * This is used to retrieve a suitable size by container widgets which do
+     * not impose any restrictions on the child placement. It can be used
+     * to deduce toplevel window and menu sizes as well as child widgets in
+     * free-form containers such as `GtkFixed`.
+     *
+     * Handle with care. Note that the natural height of a height-for-width
+     * widget will generally be a smaller size than the minimum height, since
+     * the required height for the natural width is generally smaller than the
+     * required height for the minimum width.
+     *
+     * Use [method@Gtk.Widget.measure] if you want to support baseline alignment.
+     * @param minimumSize - location for storing the minimum size
+     * @param naturalSize - location for storing the natural size
+     */
     getPreferredSize(minimumSize?: Ref<Requisition> | null, naturalSize?: Ref<Requisition> | null): void;
+    /**
+     * Returns the widget’s previous sibling.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getPrevSibling(): Widget | null;
+    /**
+     * Gets the primary clipboard of the widget.
+     *
+     * This is a utility function to get the primary clipboard object
+     * for the display that `widget` is using.
+     *
+     * Note that this function always works, even when `widget` is not
+     * realized yet.
+     */
     getPrimaryClipboard(): Gdk.Clipboard;
+    /**
+     * Determines whether the widget is realized.
+     */
     getRealized(): boolean;
+    /**
+     * Determines whether the widget is always treated as the default widget
+     * within its toplevel when it has the focus, even if another widget
+     * is the default.
+     *
+     * See [method@Gtk.Widget.set_receives_default].
+     */
     getReceivesDefault(): boolean;
+    /**
+     * Gets whether the widget prefers a height-for-width layout
+     * or a width-for-height layout.
+     *
+     * Single-child widgets generally propagate the preference of
+     * their child, more complex widgets need to request something
+     * either in context of their children or in context of their
+     * allocation capabilities.
+     */
     getRequestMode(): SizeRequestMode;
+    /**
+     * Returns the `GtkRoot` widget of the widget.
+     *
+     * This function will return `NULL` if the widget is not contained
+     * inside a widget tree with a root widget.
+     *
+     * `GtkRoot` widgets will return themselves here.
+     */
     getRoot(): Root | null;
+    /**
+     * Retrieves the internal scale factor that maps from window
+     * coordinates to the actual device pixels.
+     *
+     * On traditional systems this is 1, on high density outputs,
+     * it can be a higher value (typically 2).
+     *
+     * See [method@Gdk.Surface.get_scale_factor].
+     *
+     * Note that modern systems may support *fractional* scaling,
+     * where the scale factor is not an integer. On such systems,
+     * this function will return the next higher integer value,
+     * but you probably want to use [method@Gdk.Surface.get_scale]
+     * to get the fractional scale value.
+     */
     getScaleFactor(): number;
+    /**
+     * Returns the widget’s sensitivity.
+     *
+     * This function returns the value that has been set using
+     * [method@Gtk.Widget.set_sensitive]).
+     *
+     * The effective sensitivity of a widget is however determined
+     * by both its own and its parent widget’s sensitivity.
+     * See [method@Gtk.Widget.is_sensitive].
+     */
     getSensitive(): boolean;
+    /**
+     * Gets the settings object holding the settings used for the widget.
+     *
+     * Note that this function can only be called when the `GtkWidget`
+     * is attached to a toplevel, since the settings object is specific
+     * to a particular display. If you want to monitor the widget for
+     * changes in its settings, connect to the `notify::display` signal.
+     */
     getSettings(): Settings;
+    /**
+     * Returns the content width or height of the widget.
+     *
+     * Which dimension is returned depends on @orientation.
+     *
+     * This is equivalent to calling [method@Gtk.Widget.get_width]
+     * for [enum@Gtk.Orientation.horizontal] or [method@Gtk.Widget.get_height]
+     * for [enum@Gtk.Orientation.vertical], but can be used when
+     * writing orientation-independent code, such as when
+     * implementing [iface@Gtk.Orientable] widgets.
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     * @param orientation - the orientation to query
+     */
     getSize(orientation: Orientation): number;
+    /**
+     * Gets the size request that was explicitly set for the widget.
+     *
+     * A value of -1 stored in `width` or `height` indicates that that
+     * dimension has not been set explicitly and the natural requisition
+     * of the widget will be used instead.
+     *
+     * See [method@Gtk.Widget.set_size_request].
+     *
+     * To get the size a widget will actually request, call
+     * [method@Gtk.Widget.measure] instead of this function.
+     * @param width - return location for width
+     * @param height - return location for height
+     */
     getSizeRequest(width?: Ref<number> | null, height?: Ref<number> | null): void;
+    /**
+     * Returns the widget state as a flag set.
+     *
+     * It is worth mentioning that the effective [flags@Gtk.StateFlags.insensitive]
+     * state will be returned, that is, also based on parent insensitivity,
+     * even if `widget` itself is sensitive.
+     *
+     * Also note that if you are looking for a way to obtain the
+     * [flags@Gtk.StateFlags] to pass to a [class@Gtk.StyleContext]
+     * method, you should look at [method@Gtk.StyleContext.get_state].
+     */
     getStateFlags(): StateFlags;
+    /**
+     * Returns the style context associated to the widget.
+     *
+     * The returned object is guaranteed to be the same
+     * for the lifetime of @widget.
+     */
     getStyleContext(): StyleContext;
+    /**
+     * Fetches an object build from the template XML for `widget_type` in
+     * the widget.
+     *
+     * This will only report children which were previously declared
+     * with [method@Gtk.WidgetClass.bind_template_child_full] or one of its
+     * variants.
+     *
+     * This function is only meant to be called for code which is private
+     * to the `widget_type` which declared the child and is meant for language
+     * bindings which cannot easily make use of the GObject structure offsets.
+     * @param widgetType - The `GType` to get a template child for
+     * @param name - ID of the child defined in the template XML
+     */
     getTemplateChild(widgetType: number, name: string): GObject.GObject;
+    /**
+     * Gets the contents of the tooltip for the widget.
+     *
+     * If the tooltip has not been set using
+     * [method@Gtk.Widget.set_tooltip_markup], this
+     * function returns `NULL`.
+     */
     getTooltipMarkup(): string | null;
+    /**
+     * Gets the contents of the tooltip for the widget.
+     *
+     * If the @widget's tooltip was set using
+     * [method@Gtk.Widget.set_tooltip_markup],
+     * this function will return the escaped text.
+     */
     getTooltipText(): string | null;
+    /**
+     * Gets the vertical alignment of the widget.
+     */
     getValign(): Align;
+    /**
+     * Gets whether the widget would like any available extra vertical
+     * space.
+     *
+     * See [method@Gtk.Widget.get_hexpand] for more detail.
+     */
     getVexpand(): boolean;
+    /**
+     * Gets whether the `vexpand` flag has been explicitly set.
+     *
+     * See [method@Gtk.Widget.get_hexpand_set] for more detail.
+     */
     getVexpandSet(): boolean;
+    /**
+     * Determines whether the widget is visible.
+     *
+     * If you want to take into account whether the widget’s
+     * parent is also marked as visible, use
+     * [method@Gtk.Widget.is_visible] instead.
+     *
+     * This function does not check if the widget is
+     * obscured in any way.
+     *
+     * See [method@Gtk.Widget.set_visible].
+     */
     getVisible(): boolean;
+    /**
+     * Returns the content width of the widget.
+     *
+     * This function returns the width passed to its
+     * size-allocate implementation, which is the width you
+     * should be using in [vfunc@Gtk.Widget.snapshot].
+     *
+     * For pointer events, see [method@Gtk.Widget.contains].
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getWidth(): number;
+    /**
+     * Causes `widget` to have the keyboard focus for the window
+     * that it belongs to.
+     *
+     * If `widget` is not focusable, or its [vfunc@Gtk.Widget.grab_focus]
+     * implementation cannot transfer the focus to a descendant of `widget` that is focusable, it will not take focus and false will be returned.
+     *
+     * Calling [method@Gtk.Widget.grab_focus] on an already focused widget
+     * is allowed, should not have an effect, and return true.
+     */
     grabFocus(): boolean;
+    /**
+     * Returns whether a style class is currently applied to the widget.
+     * @param cssClass - style class, without the leading period
+     */
     hasCssClass(cssClass: string): boolean;
+    /**
+     * Determines whether the widget is the current default widget
+     * within its toplevel.
+     */
     hasDefault(): boolean;
+    /**
+     * Determines if the widget has the global input focus.
+     *
+     * See [method@Gtk.Widget.is_focus] for the difference between
+     * having the global input focus, and only having the focus
+     * within a toplevel.
+     */
     hasFocus(): boolean;
+    /**
+     * Determines if the widget should show a visible indication that
+     * it has the global input focus.
+     *
+     * This is a convenience function that takes into account whether
+     * focus indication should currently be shown in the toplevel window
+     * of @widget. See [method@Gtk.Window.get_focus_visible] for more
+     * information about focus indication.
+     *
+     * To find out if the widget has the global input focus, use
+     * [method@Gtk.Widget.has_focus].
+     */
     hasVisibleFocus(): boolean;
+    /**
+     * Reverses the effects of [method.Gtk.Widget.show].
+     *
+     * This is causing the widget to be hidden (invisible to the user).
+     */
     hide(): void;
+    /**
+     * Returns whether the widget is currently being destroyed.
+     *
+     * This information can sometimes be used to avoid doing
+     * unnecessary work.
+     */
     inDestruction(): boolean;
+    /**
+     * Creates and initializes child widgets defined in templates.
+     *
+     * This function must be called in the instance initializer
+     * for any class which assigned itself a template using
+     * [method@Gtk.WidgetClass.set_template].
+     *
+     * It is important to call this function in the instance initializer
+     * of a widget subclass and not in `GObject.constructed()` or
+     * `GObject.constructor()` for two reasons:
+     *
+     * - derived widgets will assume that the composite widgets
+     * defined by its parent classes have been created in their
+     * relative instance initializers
+     * - when calling `g_object_new()` on a widget with composite templates,
+     * it’s important to build the composite widgets before the construct
+     * properties are set. Properties passed to `g_object_new()` should
+     * take precedence over properties set in the private template XML
+     *
+     * A good rule of thumb is to call this function as the first thing in
+     * an instance initialization function.
+     */
     initTemplate(): void;
+    /**
+     * Inserts an action group into the widget's actions.
+     *
+     * Children of `widget` that implement [iface@Gtk.Actionable] can
+     * then be associated with actions in `group` by setting their
+     * “action-name” to @prefix.`action-name`.
+     *
+     * Note that inheritance is defined for individual actions. I.e.
+     * even if you insert a group with prefix @prefix, actions with
+     * the same prefix will still be inherited from the parent, unless
+     * the group contains an action with the same name.
+     *
+     * If `group` is `NULL`, a previously inserted group for `name` is
+     * removed from @widget.
+     * @param name - the prefix for actions in @group
+     * @param group - an action group
+     */
     insertActionGroup(name: string, group?: Gio.ActionGroup | null): void;
+    /**
+     * Sets the parent widget of the widget.
+     *
+     * In contrast to [method@Gtk.Widget.set_parent], this function
+     * inserts `widget` at a specific position into the list of children
+     * of the `parent` widget.
+     *
+     * It will be placed after @previous_sibling, or at the beginning if
+     * `previous_sibling` is `NULL`.
+     *
+     * After calling this function, `gtk_widget_get_prev_sibling (widget)`
+     * will return @previous_sibling.
+     *
+     * If `parent` is already set as the parent widget of @widget, this
+     * function can also be used to reorder `widget` in the child widget
+     * list of @parent.
+     *
+     * This function is primarily meant for widget implementations; if you are
+     * just using a widget, you *must* use its own API for adding children.
+     * @param parent - the parent widget to insert `widget` into
+     * @param previousSibling - the new previous sibling of @widget
+     */
     insertAfter(parent: Widget, previousSibling?: Widget | null): void;
+    /**
+     * Sets the parent widget of the widget.
+     *
+     * In contrast to [method@Gtk.Widget.set_parent], this function
+     * inserts `widget` at a specific position into the list of children
+     * of the `parent` widget.
+     *
+     * It will be placed before @next_sibling, or at the end if
+     * `next_sibling` is `NULL`.
+     *
+     * After calling this function, `gtk_widget_get_next_sibling (widget)`
+     * will return @next_sibling.
+     *
+     * If `parent` is already set as the parent widget of @widget, this function
+     * can also be used to reorder `widget` in the child widget list of @parent.
+     *
+     * This function is primarily meant for widget implementations; if you are
+     * just using a widget, you *must* use its own API for adding children.
+     * @param parent - the parent widget to insert `widget` into
+     * @param nextSibling - the new next sibling of @widget
+     */
     insertBefore(parent: Widget, nextSibling?: Widget | null): void;
+    /**
+     * Determines whether the widget is a descendent of @ancestor.
+     * @param ancestor - another `GtkWidget`
+     */
     isAncestor(ancestor: Widget): boolean;
+    /**
+     * Determines whether the widget can be drawn to.
+     *
+     * A widget can be drawn if it is mapped and visible.
+     */
     isDrawable(): boolean;
+    /**
+     * Determines if the widget is the focus widget within its
+     * toplevel.
+     *
+     * This does not mean that the [property@Gtk.Widget:has-focus]
+     * property is necessarily set; [property@Gtk.Widget:has-focus]
+     * will only be set if the toplevel widget additionally has the
+     * global input focus.
+     */
     isFocus(): boolean;
+    /**
+     * Returns the widget’s effective sensitivity.
+     *
+     * This means it is sensitive itself and also its
+     * parent widget is sensitive.
+     */
     isSensitive(): boolean;
+    /**
+     * Determines whether the widget and all its parents are marked as
+     * visible.
+     *
+     * This function does not check if the widget is obscured in any way.
+     *
+     * See also [method@Gtk.Widget.get_visible] and
+     * [method@Gtk.Widget.set_visible].
+     */
     isVisible(): boolean;
+    /**
+     * Emits the [signal@Gtk.Widget::keynav-failed] signal on the widget.
+     *
+     * This function should be called whenever keyboard navigation
+     * within a single widget hits a boundary.
+     *
+     * The return value of this function should be interpreted
+     * in a way similar to the return value of
+     * [method@Gtk.Widget.child_focus]. When true is returned,
+     * stay in the widget, the failed keyboard navigation is ok
+     * and/or there is nowhere we can/should move the focus to.
+     * When false is returned, the caller should continue with
+     * keyboard navigation outside the widget, e.g. by calling
+     * [method@Gtk.Widget.child_focus] on the widget’s toplevel.
+     *
+     * The default [signal@Gtk.Widget::keynav-failed] handler returns
+     * false for [enum@Gtk.DirectionType.tab-forward] and
+     * [enum@Gtk.DirectionType.tab-backward]. For the other values
+     * of [enum@Gtk.DirectionType] it returns true.
+     *
+     * Whenever the default handler returns true, it also calls
+     * [method@Gtk.Widget.error_bell] to notify the user of the
+     * failed keyboard navigation.
+     *
+     * A use case for providing an own implementation of `::keynav-failed`
+     * (either by connecting to it or by overriding it) would be a row of
+     * [class@Gtk.Entry] widgets where the user should be able to navigate
+     * the entire row with the cursor keys, as e.g. known from user
+     * interfaces that require entering license keys.
+     * @param direction - direction of focus movement
+     */
     keynavFailed(direction: DirectionType): boolean;
+    /**
+     * Returns the widgets for which this widget is the target of a
+     * mnemonic.
+     *
+     * Typically, these widgets will be labels. See, for example,
+     * [method@Gtk.Label.set_mnemonic_widget].
+     *
+     * The widgets in the list are not individually referenced.
+     * If you want to iterate through the list and perform actions
+     * involving callbacks that might destroy the widgets, you
+     * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+     * first, and then unref all the widgets afterwards.
+     */
     listMnemonicLabels(): Widget[];
+    /**
+     * Causes a widget to be mapped if it isn’t already.
+     *
+     * This function is only for use in widget implementations.
+     */
     map(): void;
+    /**
+     * Measures `widget` in the orientation `orientation` and for the given @for_size.
+     *
+     * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size` is 300, this functions will compute the minimum and natural width of `widget` if it is allocated at a height of 300 pixels.
+     *
+     * See GtkWidget’s geometry management section for
+     * a more details on implementing `GtkWidgetClass.measure()`.
+     * @param orientation - the orientation to measure
+     * @param forSize - Size for the opposite of @orientation, i.e.
+     * @param minimum - location to store the minimum size
+     * @param natural - location to store the natural size
+     * @param minimumBaseline - location to store the baseline
+     * @param naturalBaseline - location to store the baseline
+     */
     measure(orientation: Orientation, forSize: number, minimum?: Ref<number> | null, natural?: Ref<number> | null, minimumBaseline?: Ref<number> | null, naturalBaseline?: Ref<number> | null): void;
+    /**
+     * Emits the [signal@Gtk.Widget::mnemonic-activate] signal.
+     * @param groupCycling - true if there are other widgets with the same mnemonic
+     */
     mnemonicActivate(groupCycling: boolean): boolean;
+    /**
+     * Returns a list model to track the children of the widget.
+     *
+     * Calling this function will enable extra internal bookkeeping
+     * to track children and emit signals on the returned listmodel.
+     * It may slow down operations a lot.
+     *
+     * Applications should try hard to avoid calling this function
+     * because of the slowdowns.
+     */
     observeChildren(): Gio.ListModel;
+    /**
+     * Returns a list model to track the event controllers of the widget.
+     *
+     * Calling this function will enable extra internal bookkeeping
+     * to track controllers and emit signals on the returned listmodel.
+     * It may slow down operations a lot.
+     *
+     * Applications should try hard to avoid calling this function
+     * because of the slowdowns.
+     */
     observeControllers(): Gio.ListModel;
+    /**
+     * Finds the descendant of the widget closest to a point.
+     *
+     * The point (x, y) must be given in widget coordinates, so (0, 0)
+     * is assumed to be the top left of @widget's content area.
+     *
+     * Usually widgets will return `NULL` if the given coordinate is not
+     * contained in `widget` checked via [method@Gtk.Widget.contains].
+     * Otherwise they will recursively try to find a child that does
+     * not return `NULL`. Widgets are however free to customize their
+     * picking algorithm.
+     *
+     * This function is used on the toplevel to determine the widget
+     * below the mouse cursor for purposes of hover highlighting and
+     * delivering events.
+     * @param x - x coordinate to test, relative to @widget's origin
+     * @param y - y coordinate to test, relative to @widget's origin
+     * @param flags - flags to influence what is picked
+     */
     pick(x: number, y: number, flags: PickFlags): Widget | null;
+    /**
+     * Flags the widget for a rerun of the [vfunc@Gtk.Widget.size_allocate]
+     * function.
+     *
+     * Use this function instead of [method@Gtk.Widget.queue_resize]
+     * when the @widget's size request didn't change but it wants to
+     * reposition its contents.
+     *
+     * An example user of this function is [method@Gtk.Widget.set_halign].
+     *
+     * This function is only for use in widget implementations.
+     */
     queueAllocate(): void;
+    /**
+     * Schedules this widget to be redrawn.
+     *
+     * The redraw will happen in the paint phase
+     * of the current or the next frame.
+     *
+     * This means @widget's [vfunc@Gtk.Widget.snapshot]
+     * implementation will be called.
+     */
     queueDraw(): void;
+    /**
+     * Flags a widget to have its size renegotiated.
+     *
+     * This should be called when a widget for some reason has a new
+     * size request. For example, when you change the text in a
+     * [class@Gtk.Label], the label queues a resize to ensure there’s
+     * enough space for the new text.
+     *
+     * Note that you cannot call gtk_widget_queue_resize() on a widget
+     * from inside its implementation of the [vfunc@Gtk.Widget.size_allocate]
+     * virtual method. Calls to gtk_widget_queue_resize() from inside
+     * [vfunc@Gtk.Widget.size_allocate] will be silently ignored.
+     *
+     * This function is only for use in widget implementations.
+     */
     queueResize(): void;
+    /**
+     * Creates the GDK resources associated with a widget.
+     *
+     * Normally realization happens implicitly; if you show a widget
+     * and all its parent containers, then the widget will be realized
+     * and mapped automatically.
+     *
+     * Realizing a widget requires all the widget’s parent widgets to be
+     * realized; calling this function realizes the widget’s parents
+     * in addition to `widget` itself. If a widget is not yet inside a
+     * toplevel window when you realize it, bad things will happen.
+     *
+     * This function is primarily used in widget implementations, and
+     * isn’t very useful otherwise. Many times when you think you might
+     * need it, a better approach is to connect to a signal that will be
+     * called after the widget is realized automatically, such as
+     * [signal@Gtk.Widget::realize].
+     */
     realize(): void;
+    /**
+     * Removes an event controller from the widget.
+     *
+     * The removed event controller will not receive any more events,
+     * and should not be used again.
+     *
+     * Widgets will remove all event controllers automatically when they
+     * are destroyed, there is normally no need to call this function.
+     * @param controller - an event controller
+     */
     removeController(controller: EventController): void;
+    /**
+     * Removes a style from the widget.
+     *
+     * After this, the style of `widget` will stop matching for @css_class.
+     * @param cssClass - style class to remove from @widget, without the leading period
+     */
     removeCssClass(cssClass: string): void;
+    /**
+     * Removes a widget from the list of mnemonic labels for this widget.
+     *
+     * See [method@Gtk.Widget.list_mnemonic_labels].
+     *
+     * The widget must have previously been added to the list with
+     * [method@Gtk.Widget.add_mnemonic_label].
+     * @param label - a widget that is a mnemonic label for @widget
+     */
     removeMnemonicLabel(label: Widget): void;
+    /**
+     * Removes a tick callback previously registered with
+     * [method@Gtk.Widget.add_tick_callback].
+     * @param id - an ID returned by [method@Gtk.Widget.add_tick_callback]
+     */
     removeTickCallback(id: number): void;
+    /**
+     * Sets whether the input focus can enter the widget or
+     * any of its children.
+     *
+     * Applications should set `can_focus` to false to mark a
+     * widget as for pointer/touch use only.
+     *
+     * Note that having `can_focus` be true is only one of the
+     * necessary conditions for being focusable. A widget must
+     * also be sensitive and focusable and not have an ancestor
+     * that is marked as not can-focus in order to receive input
+     * focus.
+     *
+     * See [method@Gtk.Widget.grab_focus] for actually setting
+     * the input focus on a widget.
+     * @param canFocus - whether the input focus can enter
+     */
     setCanFocus(canFocus: boolean): void;
+    /**
+     * Sets whether the widget can be the target of pointer events.
+     * @param canTarget - whether this widget should be able to
+     */
     setCanTarget(canTarget: boolean): void;
+    /**
+     * Sets whether the widget should be mapped along with its parent.
+     *
+     * The child visibility can be set for widget before it is added
+     * to a container with [method@Gtk.Widget.set_parent], to avoid
+     * mapping children unnecessary before immediately unmapping them.
+     * However it will be reset to its default state of true when the
+     * widget is removed from a container.
+     *
+     * Note that changing the child visibility of a widget does not
+     * queue a resize on the widget. Most of the time, the size of
+     * a widget is computed from all visible children, whether or
+     * not they are mapped. If this is not the case, the container
+     * can queue a resize itself.
+     *
+     * This function is only useful for widget implementations
+     * and should never be called by an application.
+     * @param childVisible - whether `widget` should be mapped along
+     */
     setChildVisible(childVisible: boolean): void;
+    /**
+     * Replaces the current style classes of the widget with @classes.
+     * @param classes - `NULL`-terminated list of style classes
+     */
     setCssClasses(classes: string[]): void;
+    /**
+     * Sets the cursor to be shown when the pointer hovers over
+     * the widget.
+     *
+     * If the `cursor` is `NULL`, `widget` will use the cursor
+     * inherited from its parent.
+     * @param cursor - the new cursor
+     */
     setCursor(cursor?: Gdk.Cursor | null): void;
+    /**
+     * Sets the cursor to be shown when the pointer hovers over
+     * the widget.
+     *
+     * This is a utility function that creates a cursor via
+     * [ctor@Gdk.Cursor.new_from_name] and then sets it on `widget` with [method@Gtk.Widget.set_cursor]. See those functions for
+     * details.
+     *
+     * On top of that, this function allows `name` to be `NULL`, which
+     * will do the same as calling [method@Gtk.Widget.set_cursor]
+     * with a `NULL` cursor.
+     * @param name - the name of the cursor
+     */
     setCursorFromName(name?: string | null): void;
+    /**
+     * Sets the reading direction on the widget.
+     *
+     * This direction controls the primary direction for widgets
+     * containing text, and also the direction in which the children
+     * of a container are packed. The ability to set the direction is
+     * present in order so that correct localization into languages with
+     * right-to-left reading directions can be done.
+     *
+     * Generally, applications will let the default reading direction
+     * prevail, except for widgets where the children are arranged in
+     * an order that is explicitly visual rather than logical (such as
+     * buttons for text justification).
+     *
+     * If the direction is set to [enum@Gtk.TextDirection.none], then
+     * the value set by [func@Gtk.Widget.set_default_direction] will be used.
+     * @param dir - the new direction
+     */
     setDirection(dir: TextDirection): void;
+    /**
+     * Set the focus child of the widget.
+     *
+     * This function is only suitable for widget implementations.
+     * If you want a certain widget to get the input focus, call
+     * [method@Gtk.Widget.grab_focus] on it.
+     * @param child - a direct child widget of `widget`   or `NULL` to unset the focus child
+     */
     setFocusChild(child?: Widget | null): void;
+    /**
+     * Sets whether the widget should grab focus when it is clicked
+     * with the mouse.
+     *
+     * Making mouse clicks not grab focus is useful in places like
+     * toolbars where you don’t want the keyboard focus removed from
+     * the main area of the application.
+     * @param focusOnClick - whether the widget should grab focus when clicked
+     */
     setFocusOnClick(focusOnClick: boolean): void;
+    /**
+     * Sets whether the widget can own the input focus.
+     *
+     * Widget implementations should set `focusable` to true in
+     * their init() function if they want to receive keyboard input.
+     *
+     * Note that having `focusable` be true is only one of the
+     * necessary conditions for being focusable. A widget must
+     * also be sensitive and can-focus and not have an ancestor
+     * that is marked as not can-focus in order to receive input
+     * focus.
+     *
+     * See [method@Gtk.Widget.grab_focus] for actually setting
+     * the input focus on a widget.
+     * @param focusable - whether or not `widget` can own the input focus
+     */
     setFocusable(focusable: boolean): void;
+    /**
+     * Sets the font map to use for text rendering in the widget.
+     *
+     * The font map is the object that is used to look up fonts.
+     * Setting a custom font map can be useful in special situations,
+     * e.g. when you need to add application-specific fonts to the set
+     * of available fonts.
+     *
+     * When not set, the widget will inherit the font map from its parent.
+     * @param fontMap - a `PangoFontMap`
+     */
     setFontMap(fontMap?: Pango.FontMap | null): void;
+    /**
+     * Sets the `cairo_font_options_t` used for text rendering
+     * in the widget.
+     *
+     * When not set, the default font options for the `GdkDisplay`
+     * will be used.
+     * @param options - a `cairo_font_options_t` struct
+     */
     setFontOptions(options?: cairo.FontOptions | null): void;
+    /**
+     * Sets the horizontal alignment of the widget.
+     * @param align - the horizontal alignment
+     */
     setHalign(align: Align): void;
+    /**
+     * Sets the `has-tooltip` property on the widget.
+     * @param hasTooltip - whether or not `widget` has a tooltip
+     */
     setHasTooltip(hasTooltip: boolean): void;
+    /**
+     * Sets whether the widget would like any available extra horizontal
+     * space.
+     *
+     * When a user resizes a window, widgets with expand set to true generally
+     * receive the extra space. For example, a list or scrollable area
+     * or document in your window would often be set to expand.
+     *
+     * Call this function to set the expand flag if you would like your
+     * widget to become larger horizontally when the window has extra
+     * room.
+     *
+     * By default, widgets automatically expand if any of their children
+     * want to expand. (To see if a widget will automatically expand given
+     * its current children and state, call [method@Gtk.Widget.compute_expand].
+     * A widget can decide how the expandability of children affects its
+     * own expansion by overriding the `compute_expand` virtual method on
+     * `GtkWidget`.).
+     *
+     * Setting hexpand explicitly with this function will override the
+     * automatic expand behavior.
+     *
+     * This function forces the widget to expand or not to expand,
+     * regardless of children. The override occurs because
+     * [method@Gtk.Widget.set_hexpand] sets the hexpand-set property (see
+     * [method@Gtk.Widget.set_hexpand_set]) which causes the widget’s hexpand
+     * value to be used, rather than looking at children and widget state.
+     * @param expand - whether to expand
+     */
     setHexpand(expand: boolean): void;
+    /**
+     * Sets whether the hexpand flag will be used.
+     *
+     * The [property@Gtk.Widget:hexpand-set] property will be set
+     * automatically when you call [method@Gtk.Widget.set_hexpand]
+     * to set hexpand, so the most likely reason to use this function
+     * would be to unset an explicit expand flag.
+     *
+     * If hexpand is set, then it overrides any computed
+     * expand value based on child widgets. If hexpand is not
+     * set, then the expand value depends on whether any
+     * children of the widget would like to expand.
+     *
+     * There are few reasons to use this function, but it’s here
+     * for completeness and consistency.
+     * @param set - value for hexpand-set property
+     */
     setHexpandSet(set: boolean): void;
+    /**
+     * Sets the layout manager to use for measuring and allocating children
+     * of the widget.
+     * @param layoutManager - a layout manager
+     */
     setLayoutManager(layoutManager?: LayoutManager | null): void;
+    /**
+     * Sets whether the widget acts like a modal dialog,
+     * with respect to event delivery.
+     * @param limitEvents - whether to limit events
+     */
     setLimitEvents(limitEvents: boolean): void;
+    /**
+     * Sets the bottom margin of the widget.
+     * @param margin - the bottom margin
+     */
     setMarginBottom(margin: number): void;
+    /**
+     * Sets the end margin of the widget.
+     * @param margin - the end margin
+     */
     setMarginEnd(margin: number): void;
+    /**
+     * Sets the start margin of the widget.
+     * @param margin - the start margin
+     */
     setMarginStart(margin: number): void;
+    /**
+     * Sets the top margin of the widget.
+     * @param margin - the top margin
+     */
     setMarginTop(margin: number): void;
+    /**
+     * Sets a widgets name.
+     *
+     * Setting a name allows you to refer to the widget from a
+     * CSS file. You can apply a style to widgets with a particular name
+     * in the CSS file. See the documentation for the CSS syntax (on the
+     * same page as the docs for [class@Gtk.StyleContext].
+     *
+     * Note that the CSS syntax has certain special characters to delimit
+     * and represent elements in a selector (period, #, >, *...), so using
+     * these will make your widget impossible to match by name. Any combination
+     * of alphanumeric symbols, dashes and underscores will suffice.
+     * @param name - name for the widget
+     */
     setName(name: string): void;
+    /**
+     * Requests the widget to be rendered partially transparent.
+     *
+     * An opacity of 0 is fully transparent and an opacity of 1
+     * is fully opaque.
+     *
+     * Opacity works on both toplevel widgets and child widgets, although
+     * there are some limitations: For toplevel widgets, applying opacity
+     * depends on the capabilities of the windowing system. On X11, this
+     * has any effect only on X displays with a compositing manager, see
+     * [method@Gdk.Display.is_composited]. On Windows and Wayland it will
+     * always work, although setting a window’s opacity after the window
+     * has been shown may cause some flicker.
+     *
+     * Note that the opacity is inherited through inclusion — if you set
+     * a toplevel to be partially translucent, all of its content will
+     * appear translucent, since it is ultimatively rendered on that
+     * toplevel. The opacity value itself is not inherited by child
+     * widgets (since that would make widgets deeper in the hierarchy
+     * progressively more translucent). As a consequence, [class@Gtk.Popover]
+     * instances and other [iface@Gtk.Native] widgets with their own surface
+     * will use their own opacity value, and thus by default appear
+     * non-translucent, even if they are attached to a toplevel that
+     * is translucent.
+     * @param opacity - desired opacity, between 0 and 1
+     */
     setOpacity(opacity: number): void;
+    /**
+     * Sets how the widget treats content that is drawn outside the
+     * it's content area.
+     *
+     * See the definition of [enum@Gtk.Overflow] for details.
+     *
+     * This setting is provided for widget implementations and
+     * should not be used by application code.
+     *
+     * The default value is [enum@Gtk.Overflow.visible].
+     * @param overflow - desired overflow value
+     */
     setOverflow(overflow: Overflow): void;
+    /**
+     * Sets the parent widget of the widget.
+     *
+     * This takes care of details such as updating the state and style
+     * of the child to reflect its new location and resizing the parent.
+     * The opposite function is [method@Gtk.Widget.unparent].
+     *
+     * This function is useful only when implementing subclasses of
+     * `GtkWidget`.
+     * @param parent - parent widget
+     */
     setParent(parent: Widget): void;
+    /**
+     * Sets whether the widget will be treated as the default
+     * widget within its toplevel when it has the focus, even if
+     * another widget is the default.
+     * @param receivesDefault - whether or not `widget` can be a default widget
+     */
     setReceivesDefault(receivesDefault: boolean): void;
+    /**
+     * Sets the sensitivity of the widget.
+     *
+     * A widget is sensitive if the user can interact with it.
+     * Insensitive widgets are “grayed out” and the user can’t
+     * interact with them. Insensitive widgets are known as
+     * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+     * @param sensitive - true to make the widget sensitive
+     */
     setSensitive(sensitive: boolean): void;
+    /**
+     * Sets the minimum size of the widget.
+     *
+     * That is, the widget’s size request will be at least `width` by @height. You can use this function to force a widget to
+     * be larger than it normally would be.
+     *
+     * In most cases, [method@Gtk.Window.set_default_size] is a better
+     * choice for toplevel windows than this function; setting the default
+     * size will still allow users to shrink the window. Setting the size
+     * request will force them to leave the window at least as large as
+     * the size request.
+     *
+     * Note the inherent danger of setting any fixed size - themes,
+     * translations into other languages, different fonts, and user action
+     * can all change the appropriate size for a given widget. So, it is
+     * basically impossible to hardcode a size that will always work.
+     *
+     * The size request of a widget is the smallest size a widget can
+     * accept while still functioning well and drawing itself correctly.
+     * However in some strange cases a widget may be allocated less than
+     * its requested size, and in many cases a widget may be allocated more
+     * space than it requested.
+     *
+     * If the size request in a given direction is -1 (unset), then
+     * the “natural” size request of the widget will be used instead.
+     *
+     * The size request set here does not include any margin from the
+     * properties
+     * [property@Gtk.Widget:margin-start],
+     * [property@Gtk.Widget:margin-end],
+     * [property@Gtk.Widget:margin-top], and
+     * [property@Gtk.Widget:margin-bottom], but it does include pretty
+     * much all other padding or border properties set by any subclass
+     * of `GtkWidget`.
+     * @param width - width `widget` should request, or -1 to unset
+     * @param height - height `widget` should request, or -1 to unset
+     */
     setSizeRequest(width: number, height: number): void;
+    /**
+     * Turns on flag values in the current widget state.
+     *
+     * Typical widget states are insensitive, prelighted, etc.
+     *
+     * This function accepts the values [flags@Gtk.StateFlags.dir-ltr] and
+     * [flags@Gtk.StateFlags.dir-rtl] but ignores them. If you want to set
+     * the widget's direction, use [method@Gtk.Widget.set_direction].
+     *
+     * This function is for use in widget implementations.
+     * @param flags - state flags to turn on
+     * @param clear - whether to clear state before turning on @flags
+     */
     setStateFlags(flags: StateFlags, clear: boolean): void;
+    /**
+     * Sets the contents of the tooltip for widget.
+     *
+     * `markup` must contain Pango markup.
+     *
+     * This function will take care of setting the
+     * [property@Gtk.Widget:has-tooltip] as a side effect, and of the
+     * default handler for the [signal@Gtk.Widget::query-tooltip] signal.
+     *
+     * See also [method@Gtk.Tooltip.set_markup].
+     * @param markup - the contents of the tooltip for @widget
+     */
     setTooltipMarkup(markup?: string | null): void;
+    /**
+     * Sets the contents of the tooltip for the widget.
+     *
+     * If `text` contains any markup, it will be escaped.
+     *
+     * This function will take care of setting
+     * [property@Gtk.Widget:has-tooltip] as a side effect,
+     * and of the default handler for the
+     * [signal@Gtk.Widget::query-tooltip] signal.
+     *
+     * See also [method@Gtk.Tooltip.set_text].
+     * @param text - the contents of the tooltip for @widget
+     */
     setTooltipText(text?: string | null): void;
+    /**
+     * Sets the vertical alignment of the widget.
+     * @param align - the vertical alignment
+     */
     setValign(align: Align): void;
+    /**
+     * Sets whether the widget would like any available extra vertical
+     * space.
+     *
+     * See [method@Gtk.Widget.set_hexpand] for more detail.
+     * @param expand - whether to expand
+     */
     setVexpand(expand: boolean): void;
+    /**
+     * Sets whether the vexpand flag will be used.
+     *
+     * See [method@Gtk.Widget.set_hexpand_set] for more detail.
+     * @param set - value for vexpand-set property
+     */
     setVexpandSet(set: boolean): void;
+    /**
+     * Sets the visibility state of @widget.
+     *
+     * Note that setting this to true doesn’t mean the widget is
+     * actually viewable, see [method@Gtk.Widget.get_visible].
+     * @param visible - whether the widget should be shown or not
+     */
     setVisible(visible: boolean): void;
+    /**
+     * Returns whether the widget should contribute to
+     * the measuring and allocation of its parent.
+     *
+     * This is false for invisible children, but also
+     * for children that have their own surface, such
+     * as [class@Gtk.Popover] instances.
+     */
     shouldLayout(): boolean;
+    /**
+     * Flags a widget to be displayed.
+     *
+     * Any widget that isn’t shown will not appear on the screen.
+     *
+     * Remember that you have to show the containers containing a widget,
+     * in addition to the widget itself, before it will appear onscreen.
+     *
+     * When a toplevel widget is shown, it is immediately realized and
+     * mapped; other shown widgets are realized and mapped when their
+     * toplevel widget is realized and mapped.
+     */
     show(): void;
+    /**
+     * Allocates widget with a transformation that translates
+     * the origin to the position in @allocation.
+     *
+     * This is a simple form of [method@Gtk.Widget.allocate].
+     * @param allocation - position and size to be allocated to @widget
+     * @param baseline - the baseline of the child, or -1
+     */
     sizeAllocate(allocation: number, baseline: number): void;
+    /**
+     * Snapshots a child of the widget.
+     *
+     * When a widget receives a call to the snapshot function,
+     * it must send synthetic [vfunc@Gtk.Widget.snapshot] calls
+     * to all children. This function provides a convenient way
+     * of doing this. A widget, when it receives a call to its
+     * [vfunc@Gtk.Widget.snapshot] function, calls
+     * gtk_widget_snapshot_child() once for each child, passing in
+     * the `snapshot` the widget received.
+     *
+     * This function takes care of translating the origin of @snapshot,
+     * and deciding whether the child needs to be snapshot.
+     *
+     * It does nothing for children that implement `GtkNative`.
+     * @param child - a child of @widget
+     * @param snapshot - snapshot as passed to the widget. In particular, no
+     */
     snapshotChild(child: Widget, snapshot: Snapshot): void;
+    /**
+     * Translates coordinates relative to @src_widget’s allocation
+     * to coordinates relative to @dest_widget’s allocations.
+     *
+     * In order to perform this operation, both widget must share
+     * a common ancestor. If that is not the case, `dest_x` and `dest_y` are set to 0 and false is returned.
+     * @param destWidget - another widget
+     * @param srcX - X position in widget coordinates of @src_widget
+     * @param srcY - Y position in widget coordinates of @src_widget
+     * @param destX - location to store X position in widget coordinates of @dest_widget
+     * @param destY - location to store Y position in widget coordinates of @dest_widget
+     */
     translateCoordinates(destWidget: Widget, srcX: number, srcY: number, destX?: Ref<number> | null, destY?: Ref<number> | null): boolean;
+    /**
+     * Triggers a tooltip query on the display of the widget.
+     */
     triggerTooltipQuery(): void;
+    /**
+     * Causes a widget to be unmapped if it’s currently mapped.
+     *
+     * This function is only for use in widget implementations.
+     */
     unmap(): void;
+    /**
+     * Removes `widget` from its parent.
+     *
+     * This function is only for use in widget implementations,
+     * typically in dispose.
+     */
     unparent(): void;
+    /**
+     * Causes a widget to be unrealized.
+     *
+     * This frees all GDK resources associated with the widget.
+     *
+     * This function is only useful in widget implementations.
+     */
     unrealize(): void;
+    /**
+     * Turns off flag values for the current widget state.
+     *
+     * See [method@Gtk.Widget.set_state_flags].
+     *
+     * This function is for use in widget implementations.
+     * @param flags - state flags to turn off
+     */
     unsetStateFlags(flags: StateFlags): void;
+    /**
+     * Requests the user's screen reader to announce the given message.
+     *
+     * This kind of notification is useful for messages that
+     * either have only a visual representation or that are not
+     * exposed visually at all, e.g. a notification about a
+     * successful operation.
+     *
+     * Also, by using this API, you can ensure that the message
+     * does not interrupts the user's current screen reader output.
+     * @param message - the string to announce
+     * @param priority - the priority of the announcement
+     */
     announce(message: string, priority: AccessibleAnnouncementPriority): void;
+    /**
+     * Retrieves the accessible parent for an accessible object.
+     *
+     * This function returns `NULL` for top level widgets.
+     */
     getAccessibleParent(): Accessible | null;
+    /**
+     * Retrieves the accessible role of an accessible object.
+     */
     getAccessibleRole(): AccessibleRole;
+    /**
+     * Retrieves the implementation for the given accessible object.
+     */
     getAtContext(): ATContext;
+    /**
+     * Queries the coordinates and dimensions of this accessible
+     *
+     * This functionality can be overridden by `GtkAccessible`
+     * implementations, e.g. to get the bounds from an ignored
+     * child widget.
+     * @param x - the x coordinate of the top left corner of the accessible
+     * @param y - the y coordinate of the top left corner of the widget
+     * @param width - the width of the accessible object
+     * @param height - the height of the accessible object
+     */
     getBounds(x: Ref<number>, y: Ref<number>, width: Ref<number>, height: Ref<number>): boolean;
+    /**
+     * Retrieves the first accessible child of an accessible object.
+     */
     getFirstAccessibleChild(): Accessible | null;
+    /**
+     * Retrieves the next accessible sibling of an accessible object
+     */
     getNextAccessibleSibling(): Accessible | null;
+    /**
+     * Queries a platform state, such as focus.
+     *
+     * This functionality can be overridden by `GtkAccessible`
+     * implementations, e.g. to get platform state from an ignored
+     * child widget, as is the case for `GtkText` wrappers.
+     * @param state - platform state to query
+     */
     getPlatformState(state: AccessiblePlatformState): boolean;
+    /**
+     * Resets the accessible property to its default value.
+     * @param property - the accessible property
+     */
     resetProperty(property: AccessibleProperty): void;
+    /**
+     * Resets the accessible relation to its default value.
+     * @param relation - the accessible relation
+     */
     resetRelation(relation: AccessibleRelation): void;
+    /**
+     * Resets the accessible state to its default value.
+     * @param state - the accessible state
+     */
     resetState(state: AccessibleState): void;
+    /**
+     * Sets the parent and sibling of an accessible object.
+     *
+     * This function is meant to be used by accessible implementations that are
+     * not part of the widget hierarchy, and but act as a logical bridge between
+     * widgets. For instance, if a widget creates an object that holds metadata
+     * for each child, and you want that object to implement the `GtkAccessible`
+     * interface, you will use this function to ensure that the parent of each
+     * child widget is the metadata object, and the parent of each metadata
+     * object is the container widget.
+     * @param parent - the parent accessible object
+     * @param nextSibling - the sibling accessible object
+     */
     setAccessibleParent(parent?: Accessible | null, nextSibling?: Accessible | null): void;
+    /**
+     * Updates the next accessible sibling.
+     *
+     * That might be useful when a new child of a custom accessible
+     * is created, and it needs to be linked to a previous child.
+     * @param newSibling - the new next accessible sibling to set
+     */
     updateNextAccessibleSibling(newSibling?: Accessible | null): void;
+    /**
+     * Informs ATs that the platform state has changed.
+     *
+     * This function should be used by `GtkAccessible` implementations that
+     * have a platform state but are not widgets. Widgets handle platform
+     * states automatically.
+     * @param state - the platform state to update
+     */
     updatePlatformState(state: AccessiblePlatformState): void;
+    /**
+     * Updates an array of accessible properties.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * property change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nProperties - the number of accessible properties to set
+     * @param properties - an array of accessible properties
+     * @param values - an array of `GValues`, one for each property
+     */
     updatePropertyValue(nProperties: number, properties: AccessibleProperty[], values: GObject.Value[]): void;
+    /**
+     * Updates an array of accessible relations.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * relation change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nRelations - the number of accessible relations to set
+     * @param relations - an array of accessible relations
+     * @param values - an array of `GValues`, one for each relation
+     */
     updateRelationValue(nRelations: number, relations: AccessibleRelation[], values: GObject.Value[]): void;
+    /**
+     * Updates an array of accessible states.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * state change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nStates - the number of accessible states to set
+     * @param states - an array of accessible states
+     * @param values - an array of `GValues`, one for each state
+     */
     updateStateValue(nStates: number, states: AccessibleState[], values: GObject.Value[]): void;
+    /**
+     * Gets the ID of the `buildable` object.
+     *
+     * `GtkBuilder` sets the name based on the ID attribute
+     * of the `<object>` tag used to construct the @buildable.
+     */
     getBuildableId(): string | null;
     connect(signal: "destroy", handler: (self: Widget) => void, after?: boolean): number;
     connect(signal: "direction-changed", handler: (self: Widget, previousDirection: TextDirection) => void, after?: boolean): number;