gtk4/auto/

widget.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#![allow(deprecated)]

use crate::{
    Accessible, Align, Allocation, Buildable, ConstraintTarget, DirectionType, EventController,
    LayoutManager, Native, Orientation, Overflow, PickFlags, Requisition, Root, Settings,
    SizeRequestMode, Snapshot, StateFlags, StyleContext, TextDirection, Tooltip, ffi,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// The base class for all widgets.
    ///
    /// It manages the widget lifecycle, layout, states and style.
    ///
    /// ### Minimum and natural size
    ///
    /// In order to understand geometry management of widgets in GTK, it is
    /// helpful to understand the different terminology surrounding sizing of
    /// widgets.
    ///
    /// The two primary terms are: *minimum size* and *natural size*.
    ///
    /// As a general rule: the *minimum size* is the size required to display
    /// the minimum amount of content in a widget. A widget cannot be
    /// allocated less than the minimum size it requires.
    ///
    /// The *natural size* is the amount of content that a widget prefers to
    /// display in normal conditions.
    ///
    /// A widget may be allocated more than the natural size it prefers, or
    /// less, depending on the layout management of its parent container.
    /// What to do when the widget is allocated a different size than
    /// the one it prefers is entirely left to the widget implementation:
    /// some widgets decide to add extra room, other widgets may disclose
    /// additional content, other widgets may decide to hide content, or show
    /// a different layout entirely.
    ///
    /// ### Height-for-width Geometry Management
    ///
    /// GTK uses a height-for-width (and width-for-height) geometry management
    /// system. Height-for-width means that a widget can change how much
    /// vertical space it needs, depending on the amount of horizontal space
    /// that it is given (and similar for width-for-height). The most common
    /// example is a label that reflows to fill up the available width, wraps
    /// to fewer lines, and therefore needs less height.
    ///
    /// Height-for-width geometry management is implemented in GTK by way
    /// of two virtual methods:
    ///
    /// - [`WidgetImpl::request_mode()`][crate::subclass::prelude::WidgetImpl::request_mode()]
    /// - [`WidgetImpl::measure()`][crate::subclass::prelude::WidgetImpl::measure()]
    ///
    /// There are some important things to keep in mind when implementing
    /// height-for-width and when using it in widget implementations.
    ///
    /// If you implement a direct [`Widget`][crate::Widget] subclass that supports
    /// height-for-width or width-for-height geometry management for itself
    /// or its child widgets, the [`WidgetImpl::request_mode()`][crate::subclass::prelude::WidgetImpl::request_mode()] virtual
    /// function must be implemented as well and return the widget's preferred
    /// request mode. The default implementation of this virtual function
    /// returns [`SizeRequestMode::ConstantSize`][crate::SizeRequestMode::ConstantSize], which means that the widget will
    /// only ever get -1 passed as the for_size value to its
    /// [`WidgetImpl::measure()`][crate::subclass::prelude::WidgetImpl::measure()] implementation.
    ///
    /// The geometry management system will query a widget hierarchy in
    /// only one orientation at a time. When widgets are initially queried
    /// for their minimum sizes it is generally done in two initial passes
    /// in the [`SizeRequestMode`][crate::SizeRequestMode] chosen by the toplevel.
    ///
    /// For example, when queried in the normal [`SizeRequestMode::HeightForWidth`][crate::SizeRequestMode::HeightForWidth] mode:
    ///
    /// First, the default minimum and natural width for each widget
    /// in the interface will be computed using [`WidgetExt::measure()`][crate::prelude::WidgetExt::measure()] with an
    /// orientation of [`Orientation::Horizontal`][crate::Orientation::Horizontal] and a for_size of -1.
    /// Because the preferred widths for each widget depend on the preferred
    /// widths of their children, this information propagates up the hierarchy,
    /// and finally a minimum and natural width is determined for the entire
    /// toplevel. Next, the toplevel will use the minimum width to query for the
    /// minimum height contextual to that width using [`WidgetExt::measure()`][crate::prelude::WidgetExt::measure()] with an
    /// orientation of [`Orientation::Vertical`][crate::Orientation::Vertical] and a for_size of the just computed
    /// width. This will also be a highly recursive operation. The minimum height
    /// for the minimum width is normally used to set the minimum size constraint
    /// on the toplevel.
    ///
    /// After the toplevel window has initially requested its size in both
    /// dimensions it can go on to allocate itself a reasonable size (or a size
    /// previously specified with [`GtkWindowExt::set_default_size()`][crate::prelude::GtkWindowExt::set_default_size()]). During the
    /// recursive allocation process it’s important to note that request cycles
    /// will be recursively executed while widgets allocate their children.
    /// Each widget, once allocated a size, will go on to first share the
    /// space in one orientation among its children and then request each child's
    /// height for its target allocated width or its width for allocated height,
    /// depending. In this way a widget will typically be requested its size
    /// a number of times before actually being allocated a size. The size a
    /// widget is finally allocated can of course differ from the size it has
    /// requested. For this reason, [`Widget`][crate::Widget] caches a  small number of results
    /// to avoid re-querying for the same sizes in one allocation cycle.
    ///
    /// If a widget does move content around to intelligently use up the
    /// allocated size then it must support the request in both
    /// [`SizeRequestMode`][crate::SizeRequestMode]s even if the widget in question only
    /// trades sizes in a single orientation.
    ///
    /// For instance, a [`Label`][crate::Label] that does height-for-width word wrapping
    /// will not expect to have [`WidgetImpl::measure()`][crate::subclass::prelude::WidgetImpl::measure()] with an orientation of
    /// [`Orientation::Vertical`][crate::Orientation::Vertical] called because that call is specific to a
    /// width-for-height request. In this case the label must return the height
    /// required for its own minimum possible width. By following this rule any
    /// widget that handles height-for-width or width-for-height requests will
    /// always be allocated at least enough space to fit its own content.
    ///
    /// Here are some examples of how a [`SizeRequestMode::HeightForWidth`][crate::SizeRequestMode::HeightForWidth] widget
    /// generally deals with width-for-height requests:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// foo_widget_measure (GtkWidget      *widget,
    ///                     GtkOrientation  orientation,
    ///                     int             for_size,
    ///                     int            *minimum_size,
    ///                     int            *natural_size,
    ///                     int            *minimum_baseline,
    ///                     int            *natural_baseline)
    /// {
    ///   if (orientation == GTK_ORIENTATION_HORIZONTAL)
    ///     {
    ///       // Calculate minimum and natural width
    ///     }
    ///   else // VERTICAL
    ///     {
    ///       if (i_am_in_height_for_width_mode)
    ///         {
    ///           int min_width, dummy;
    ///
    ///           // First, get the minimum width of our widget
    ///           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
    ///                                                   &min_width, &dummy, &dummy, &dummy);
    ///
    ///           // Now use the minimum width to retrieve the minimum and natural height to display
    ///           // that width.
    ///           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
    ///                                                   minimum_size, natural_size, &dummy, &dummy);
    ///         }
    ///       else
    ///         {
    ///           // ... some widgets do both.
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// Often a widget needs to get its own request during size request or
    /// allocation. For example, when computing height it may need to also
    /// compute width. Or when deciding how to use an allocation, the widget
    /// may need to know its natural size. In these cases, the widget should
    /// be careful to call its virtual methods directly, like in the code
    /// example above.
    ///
    /// It will not work to use the wrapper function [`WidgetExt::measure()`][crate::prelude::WidgetExt::measure()]
    /// inside your own [`WidgetImpl::size_allocate()`][crate::subclass::prelude::WidgetImpl::size_allocate()] implementation.
    /// These return a request adjusted by [`SizeGroup`][crate::SizeGroup], the widget's
    /// align and expand flags, as well as its CSS style.
    ///
    /// If a widget used the wrappers inside its virtual method implementations,
    /// then the adjustments (such as widget margins) would be applied
    /// twice. GTK therefore does not allow this and will warn if you try
    /// to do it.
    ///
    /// Of course if you are getting the size request for another widget, such
    /// as a child widget, you must use [`WidgetExt::measure()`][crate::prelude::WidgetExt::measure()]; otherwise, you
    /// would not properly consider widget margins, [`SizeGroup`][crate::SizeGroup], and
    /// so forth.
    ///
    /// GTK also supports baseline vertical alignment of widgets. This
    /// means that widgets are positioned such that the typographical baseline of
    /// widgets in the same row are aligned. This happens if a widget supports
    /// baselines, has a vertical alignment using baselines, and is inside
    /// a widget that supports baselines and has a natural “row” that it aligns to
    /// the baseline, or a baseline assigned to it by the grandparent.
    ///
    /// Baseline alignment support for a widget is also done by the
    /// [`WidgetImpl::measure()`][crate::subclass::prelude::WidgetImpl::measure()] virtual function. It allows you to report
    /// both a minimum and natural size.
    ///
    /// If a widget ends up baseline aligned it will be allocated all the space in
    /// the parent as if it was [`Align::Fill`][crate::Align::Fill], but the selected baseline can be
    /// found via [`WidgetExt::baseline()`][crate::prelude::WidgetExt::baseline()]. If the baseline has a
    /// value other than -1 you need to align the widget such that the baseline
    /// appears at the position.
    ///
    /// ### GtkWidget as GtkBuildable
    ///
    /// The [`Widget`][crate::Widget] implementation of the [`Buildable`][crate::Buildable] interface
    /// supports various custom elements to specify additional aspects of widgets
    /// that are not directly expressed as properties.
    ///
    /// If the widget uses a [`LayoutManager`][crate::LayoutManager], [`Widget`][crate::Widget] supports
    /// a custom `<layout>` element, used to define layout properties:
    ///
    /// ```xml
    /// <object class="GtkGrid" id="my_grid">
    ///   <child>
    ///     <object class="GtkLabel" id="label1">
    ///       <property name="label">Description</property>
    ///       <layout>
    ///         <property name="column">0</property>
    ///         <property name="row">0</property>
    ///         <property name="row-span">1</property>
    ///         <property name="column-span">1</property>
    ///       </layout>
    ///     </object>
    ///   </child>
    ///   <child>
    ///     <object class="GtkEntry" id="description_entry">
    ///       <layout>
    ///         <property name="column">1</property>
    ///         <property name="row">0</property>
    ///         <property name="row-span">1</property>
    ///         <property name="column-span">1</property>
    ///       </layout>
    ///     </object>
    ///   </child>
    /// </object>
    /// ```
    ///
    /// [`Widget`][crate::Widget] allows style information such as style classes to
    /// be associated with widgets, using the custom `<style>` element:
    ///
    /// ```xml
    /// <object class="GtkButton" id="button1">
    ///   <style>
    ///     <class name="my-special-button-class"/>
    ///     <class name="dark-button"/>
    ///   </style>
    /// </object>
    /// ```
    ///
    /// [`Widget`][crate::Widget] allows defining accessibility information, such as properties,
    /// relations, and states, using the custom `<accessibility>` element:
    ///
    /// ```xml
    /// <object class="GtkButton" id="button1">
    ///   <accessibility>
    ///     <property name="label">Download</property>
    ///     <relation name="labelled-by">label1</relation>
    ///   </accessibility>
    /// </object>
    /// ```
    ///
    /// ### Building composite widgets from template XML
    ///
    /// `GtkWidget `exposes some facilities to automate the procedure
    /// of creating composite widgets using "templates".
    ///
    /// To create composite widgets with [`Builder`][crate::Builder] XML, one must associate
    /// the interface description with the widget class at class initialization
    /// time using [`WidgetClassExt::set_template()`][crate::subclass::prelude::WidgetClassExt::set_template()].
    ///
    /// The interface description semantics expected in composite template descriptions
    /// is slightly different from regular [`Builder`][crate::Builder] XML.
    ///
    /// Unlike regular interface descriptions, [`WidgetClassExt::set_template()`][crate::subclass::prelude::WidgetClassExt::set_template()]
    /// will expect a `<template>` tag as a direct child of the toplevel
    /// `<interface>` tag. The `<template>` tag must specify the “class” attribute
    /// which must be the type name of the widget. Optionally, the “parent”
    /// attribute may be specified to specify the direct parent type of the widget
    /// type; this is ignored by [`Builder`][crate::Builder] but can be used by UI design tools to
    /// introspect what kind of properties and internal children exist for a given
    /// type when the actual type does not exist.
    ///
    /// The XML which is contained inside the `<template>` tag behaves as if it were
    /// added to the `<object>` tag defining the widget itself. You may set properties
    /// on a widget by inserting `<property>` tags into the `<template>` tag, and also
    /// add `<child>` tags to add children and extend a widget in the normal way you
    /// would with `<object>` tags.
    ///
    /// Additionally, `<object>` tags can also be added before and after the initial
    /// `<template>` tag in the normal way, allowing one to define auxiliary objects
    /// which might be referenced by other widgets declared as children of the
    /// `<template>` tag.
    ///
    /// Since, unlike the `<object>` tag, the `<template>` tag does not contain an
    /// “id” attribute, if you need to refer to the instance of the object itself that
    /// the template will create, simply refer to the template class name in an
    /// applicable element content.
    ///
    /// Here is an example of a template definition, which includes an example of
    /// this in the `<signal>` tag:
    ///
    /// ```xml
    /// <interface>
    ///   <template class="FooWidget" parent="GtkBox">
    ///     <property name="orientation">horizontal</property>
    ///     <property name="spacing">4</property>
    ///     <child>
    ///       <object class="GtkButton" id="hello_button">
    ///         <property name="label">Hello World</property>
    ///         <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
    ///       </object>
    ///     </child>
    ///     <child>
    ///       <object class="GtkButton" id="goodbye_button">
    ///         <property name="label">Goodbye World</property>
    ///       </object>
    ///     </child>
    ///   </template>
    /// </interface>
    /// ```
    ///
    /// Typically, you'll place the template fragment into a file that is
    /// bundled with your project, using `GResource`. In order to load the
    /// template, you need to call [`WidgetClassExt::set_template_from_resource()`][crate::subclass::prelude::WidgetClassExt::set_template_from_resource()]
    /// from the class initialization of your [`Widget`][crate::Widget] type:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// foo_widget_class_init (FooWidgetClass *klass)
    /// {
    ///   // ...
    ///
    ///   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
    ///                                                "/com/example/ui/foowidget.ui");
    /// }
    /// ```
    ///
    /// You will also need to call `Gtk::Widget::init_template()` from the
    /// instance initialization function:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// foo_widget_init (FooWidget *self)
    /// {
    ///   gtk_widget_init_template (GTK_WIDGET (self));
    ///
    ///   // Initialize the rest of the widget...
    /// }
    /// ```
    ///
    /// as well as calling `Gtk::Widget::dispose_template()` from the dispose
    /// function:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// foo_widget_dispose (GObject *gobject)
    /// {
    ///   FooWidget *self = FOO_WIDGET (gobject);
    ///
    ///   // Dispose objects for which you have a reference...
    ///
    ///   // Clear the template children for this widget type
    ///   gtk_widget_dispose_template (GTK_WIDGET (self), FOO_TYPE_WIDGET);
    ///
    ///   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
    /// }
    /// ```
    ///
    /// You can access widgets defined in the template using the
    /// `Gtk::Widget::get_template_child()` function, but you will typically declare
    /// a pointer in the instance private data structure of your type using the same
    /// name as the widget in the template definition, and call
    /// [`WidgetClassExt::bind_template_child_full()`][crate::subclass::prelude::WidgetClassExt::bind_template_child_full()] (or one of its wrapper macros
    /// `widget_class_bind_template_child()` and `widget_class_bind_template_child_private()`)
    /// with that name, e.g.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// typedef struct {
    ///   GtkWidget *hello_button;
    ///   GtkWidget *goodbye_button;
    /// } FooWidgetPrivate;
    ///
    /// G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
    ///
    /// static void
    /// foo_widget_dispose (GObject *gobject)
    /// {
    ///   gtk_widget_dispose_template (GTK_WIDGET (gobject), FOO_TYPE_WIDGET);
    ///
    ///   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
    /// }
    ///
    /// static void
    /// foo_widget_class_init (FooWidgetClass *klass)
    /// {
    ///   // ...
    ///   G_OBJECT_CLASS (klass)->dispose = foo_widget_dispose;
    ///
    ///   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
    ///                                                "/com/example/ui/foowidget.ui");
    ///   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
    ///                                                 FooWidget, hello_button);
    ///   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
    ///                                                 FooWidget, goodbye_button);
    /// }
    ///
    /// static void
    /// foo_widget_init (FooWidget *widget)
    /// {
    ///   gtk_widget_init_template (GTK_WIDGET (widget));
    /// }
    /// ```
    ///
    /// You can also use [`WidgetClassExt::bind_template_callback_full()`][crate::subclass::prelude::WidgetClassExt::bind_template_callback_full()] (or
    /// is wrapper macro `widget_class_bind_template_callback()`) to connect
    /// a signal callback defined in the template with a function visible in the
    /// scope of the class, e.g.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// // the signal handler has the instance and user data swapped
    /// // because of the swapped="yes" attribute in the template XML
    /// static void
    /// hello_button_clicked (FooWidget *self,
    ///                       GtkButton *button)
    /// {
    ///   g_print ("Hello, world!\n");
    /// }
    ///
    /// static void
    /// foo_widget_class_init (FooWidgetClass *klass)
    /// {
    ///   // ...
    ///   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
    ///                                                "/com/example/ui/foowidget.ui");
    ///   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
    /// }
    /// ```
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `can-focus`
    ///  Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `can-target`
    ///  Whether the widget can receive pointer events.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-classes`
    ///  A list of css classes applied to this widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-name`
    ///  The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `cursor`
    ///  The cursor used by @widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focusable`
    ///  Whether this widget itself will accept the input focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-default`
    ///  Whether the widget is the default widget.
    ///
    /// Readable
    ///
    ///
    /// #### `has-focus`
    ///  Whether the widget has the input focus.
    ///
    /// Readable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of the [`query-tooltip`][struct@crate::Widget#query-tooltip]
    /// signal on @widget.
    ///
    /// A true value indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the `hexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `layout-manager`
    ///  The [`LayoutManager`][crate::LayoutManager] instance to use to compute
    /// the preferred size of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `limit-events`
    ///  Makes this widget act like a modal dialog, with respect to
    /// event delivery.
    ///
    /// Global event controllers will not handle events with targets
    /// inside the widget, unless they are set up to ignore propagation
    /// limits. See [`EventControllerExt::set_propagation_limit()`][crate::prelude::EventControllerExt::set_propagation_limit()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-end`
    ///  Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-start`
    ///  Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-top`
    ///  Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `name`
    ///  The name of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `overflow`
    ///  How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `parent`
    ///  The parent widget of this widget.
    ///
    /// Readable
    ///
    ///
    /// #### `receives-default`
    ///  Whether the widget will receive the default action when it is focused.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `root`
    ///  The [`Root`][crate::Root] widget of the widget tree containing this widget.
    ///
    /// This will be `NULL` if the widget is not contained in a root widget.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Whether the widget responds to input.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the `vexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible`
    ///  Whether the widget is visible.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `width-request`
    ///  Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Accessible</h4></summary>
    ///
    ///
    /// #### `accessible-role`
    ///  The accessible role of the given [`Accessible`][crate::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `destroy`
    ///  Signals that all holders of a reference to the widget should release
    /// the reference that they hold.
    ///
    /// May result in finalization of the widget if all references are released.
    ///
    /// This signal is not suitable for saving widget state.
    ///
    ///
    ///
    ///
    /// #### `direction-changed`
    ///  Emitted when the text direction of a widget changes.
    ///
    ///
    ///
    ///
    /// #### `hide`
    ///  Emitted when @widget is hidden.
    ///
    ///
    ///
    ///
    /// #### `keynav-failed`
    ///  Emitted if keyboard navigation fails.
    ///
    /// See [`WidgetExt::keynav_failed()`][crate::prelude::WidgetExt::keynav_failed()] for details.
    ///
    ///
    ///
    ///
    /// #### `map`
    ///  Emitted when @widget is going to be mapped.
    ///
    /// A widget is mapped when the widget is visible (which is controlled with
    /// [`visible`][struct@crate::Widget#visible]) and all its parents up to the toplevel widget
    /// are also visible.
    ///
    /// The `::map` signal can be used to determine whether a widget will be drawn,
    /// for instance it can resume an animation that was stopped during the
    /// emission of [`unmap`][struct@crate::Widget#unmap].
    ///
    ///
    ///
    ///
    /// #### `mnemonic-activate`
    ///  Emitted when a widget is activated via a mnemonic.
    ///
    /// The default handler for this signal activates @widget if @group_cycling
    /// is false, or just makes @widget grab focus if @group_cycling is true.
    ///
    ///
    ///
    ///
    /// #### `move-focus`
    ///  Emitted when the focus is moved.
    ///
    /// The `::move-focus` signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are <kbd>Tab</kbd> to move forward,
    /// and <kbd>Shift</kbd>+<kbd>Tab</kbd> to move backward.
    ///
    /// Action
    ///
    ///
    /// #### `query-tooltip`
    ///  Emitted when the widget’s tooltip is about to be shown.
    ///
    /// This happens when the [`has-tooltip`][struct@crate::Widget#has-tooltip] property
    /// is true and the hover timeout has expired with the cursor hovering
    /// above @widget; or emitted when @widget got focus in keyboard mode.
    ///
    /// Using the given coordinates, the signal handler should determine
    /// whether a tooltip should be shown for @widget. If this is the case
    /// true should be returned, false otherwise. Note that if @keyboard_mode
    /// is true, the values of @x and @y are undefined and should not be used.
    ///
    /// The signal handler is free to manipulate @tooltip with the therefore
    /// destined function calls.
    ///
    ///
    ///
    ///
    /// #### `realize`
    ///  Emitted when @widget is associated with a [`gdk::Surface`][crate::gdk::Surface].
    ///
    /// This means that [`WidgetExt::realize()`][crate::prelude::WidgetExt::realize()] has been called
    /// or the widget has been mapped (that is, it is going to be drawn).
    ///
    ///
    ///
    ///
    /// #### `show`
    ///  Emitted when @widget is shown.
    ///
    ///
    ///
    ///
    /// #### `state-flags-changed`
    ///  Emitted when the widget state changes.
    ///
    /// See [`WidgetExt::state_flags()`][crate::prelude::WidgetExt::state_flags()].
    ///
    ///
    ///
    ///
    /// #### `unmap`
    ///  Emitted when @widget is going to be unmapped.
    ///
    /// A widget is unmapped when either it or any of its parents up to the
    /// toplevel widget have been set as hidden.
    ///
    /// As `::unmap` indicates that a widget will not be shown any longer,
    /// it can be used to, for example, stop an animation on the widget.
    ///
    ///
    ///
    ///
    /// #### `unrealize`
    ///  Emitted when the [`gdk::Surface`][crate::gdk::Surface] associated with @widget is destroyed.
    ///
    /// This means that [`WidgetExt::unrealize()`][crate::prelude::WidgetExt::unrealize()] has been called
    /// or the widget has been unmapped (that is, it is going to be hidden).
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`AccessibleExt`][trait@crate::prelude::AccessibleExt], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ConstraintTargetExt`][trait@crate::prelude::ConstraintTargetExt], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkWidget")]
    pub struct Widget(Object<ffi::GtkWidget, ffi::GtkWidgetClass>) @implements Accessible, Buildable, ConstraintTarget;

    match fn {
        type_ => || ffi::gtk_widget_get_type(),
    }
}

impl Widget {
    pub const NONE: Option<&'static Widget> = None;

    /// Obtains the default reading direction.
    ///
    /// See [`set_default_direction()`][Self::set_default_direction()].
    ///
    /// # Returns
    ///
    /// the current default direction
    #[doc(alias = "gtk_widget_get_default_direction")]
    #[doc(alias = "get_default_direction")]
    pub fn default_direction() -> TextDirection {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gtk_widget_get_default_direction()) }
    }

    /// Sets the default reading direction for widgets.
    ///
    /// See [`WidgetExt::set_direction()`][crate::prelude::WidgetExt::set_direction()].
    /// ## `dir`
    /// the new default direction, either [enum@Gtk.TextDirection.ltr]
    ///   or [enum@Gtk.TextDirection.rtl]
    #[doc(alias = "gtk_widget_set_default_direction")]
    pub fn set_default_direction(dir: TextDirection) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_widget_set_default_direction(dir.into_glib());
        }
    }
}

impl std::fmt::Display for Widget {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&WidgetExt::widget_name(self))
    }
}

/// Trait containing all [`struct@Widget`] methods.
///
/// # Implementors
///
/// [`ActionBar`][struct@crate::ActionBar], [`Actionable`][struct@crate::Actionable], [`AppChooserButton`][struct@crate::AppChooserButton], [`AppChooserWidget`][struct@crate::AppChooserWidget], [`AppChooser`][struct@crate::AppChooser], [`AspectFrame`][struct@crate::AspectFrame], [`Box`][struct@crate::Box], [`Button`][struct@crate::Button], [`Calendar`][struct@crate::Calendar], [`CellEditable`][struct@crate::CellEditable], [`CellView`][struct@crate::CellView], [`CenterBox`][struct@crate::CenterBox], [`CheckButton`][struct@crate::CheckButton], [`ColorButton`][struct@crate::ColorButton], [`ColorChooserWidget`][struct@crate::ColorChooserWidget], [`ColorDialogButton`][struct@crate::ColorDialogButton], [`ColumnView`][struct@crate::ColumnView], [`ComboBox`][struct@crate::ComboBox], [`DragIcon`][struct@crate::DragIcon], [`DrawingArea`][struct@crate::DrawingArea], [`DropDown`][struct@crate::DropDown], [`EditableLabel`][struct@crate::EditableLabel], [`Editable`][struct@crate::Editable], [`Entry`][struct@crate::Entry], [`Expander`][struct@crate::Expander], [`FileChooserWidget`][struct@crate::FileChooserWidget], [`Fixed`][struct@crate::Fixed], [`FlowBoxChild`][struct@crate::FlowBoxChild], [`FlowBox`][struct@crate::FlowBox], [`FontButton`][struct@crate::FontButton], [`FontChooserWidget`][struct@crate::FontChooserWidget], [`FontDialogButton`][struct@crate::FontDialogButton], [`Frame`][struct@crate::Frame], [`GLArea`][struct@crate::GLArea], [`GraphicsOffload`][struct@crate::GraphicsOffload], [`Grid`][struct@crate::Grid], [`HeaderBar`][struct@crate::HeaderBar], [`IconView`][struct@crate::IconView], [`Image`][struct@crate::Image], [`InfoBar`][struct@crate::InfoBar], [`Inscription`][struct@crate::Inscription], [`Label`][struct@crate::Label], [`LevelBar`][struct@crate::LevelBar], [`ListBase`][struct@crate::ListBase], [`ListBoxRow`][struct@crate::ListBoxRow], [`ListBox`][struct@crate::ListBox], [`MediaControls`][struct@crate::MediaControls], [`MenuButton`][struct@crate::MenuButton], [`Native`][struct@crate::Native], [`Notebook`][struct@crate::Notebook], [`Overlay`][struct@crate::Overlay], [`Paned`][struct@crate::Paned], [`PasswordEntry`][struct@crate::PasswordEntry], [`Picture`][struct@crate::Picture], [`PopoverBin`][struct@crate::PopoverBin], [`PopoverMenuBar`][struct@crate::PopoverMenuBar], [`Popover`][struct@crate::Popover], [`ProgressBar`][struct@crate::ProgressBar], [`Range`][struct@crate::Range], [`Revealer`][struct@crate::Revealer], [`Root`][struct@crate::Root], [`ScaleButton`][struct@crate::ScaleButton], [`Scrollbar`][struct@crate::Scrollbar], [`ScrolledWindow`][struct@crate::ScrolledWindow], [`SearchBar`][struct@crate::SearchBar], [`SearchEntry`][struct@crate::SearchEntry], [`Separator`][struct@crate::Separator], [`ShortcutLabel`][struct@crate::ShortcutLabel], [`ShortcutsShortcut`][struct@crate::ShortcutsShortcut], [`SpinButton`][struct@crate::SpinButton], [`Spinner`][struct@crate::Spinner], [`StackSidebar`][struct@crate::StackSidebar], [`StackSwitcher`][struct@crate::StackSwitcher], [`Stack`][struct@crate::Stack], [`Statusbar`][struct@crate::Statusbar], [`Switch`][struct@crate::Switch], [`TextView`][struct@crate::TextView], [`Text`][struct@crate::Text], [`TreeExpander`][struct@crate::TreeExpander], [`TreeView`][struct@crate::TreeView], [`Video`][struct@crate::Video], [`Viewport`][struct@crate::Viewport], [`Widget`][struct@crate::Widget], [`WindowControls`][struct@crate::WindowControls], [`WindowHandle`][struct@crate::WindowHandle], [`Window`][struct@crate::Window]
pub trait WidgetExt: IsA<Widget> + 'static {
    /// Enables or disables an action installed with
    /// [`WidgetClassExt::install_action()`][crate::subclass::prelude::WidgetClassExt::install_action()].
    /// ## `action_name`
    /// action name, such as "clipboard.paste"
    /// ## `enabled`
    /// whether the action is now enabled
    #[doc(alias = "gtk_widget_action_set_enabled")]
    fn action_set_enabled(&self, action_name: &str, enabled: bool) {
        unsafe {
            ffi::gtk_widget_action_set_enabled(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Activates the widget.
    ///
    /// The activation will emit the signal set using
    /// [`WidgetClassExt::set_activate_signal()`][crate::subclass::prelude::WidgetClassExt::set_activate_signal()]
    /// during class initialization.
    ///
    /// Activation is what happens when you press <kbd>Enter</kbd>
    /// on a widget.
    ///
    /// If you wish to handle the activation keybinding yourself,
    /// it is recommended to use [`WidgetClassExt::add_shortcut()`][crate::subclass::prelude::WidgetClassExt::add_shortcut()]
    /// with an action created with [`SignalAction::new()`][crate::SignalAction::new()].
    ///
    /// If @self is not activatable, the function returns false.
    ///
    /// # Returns
    ///
    /// true if the widget was activated
    #[doc(alias = "gtk_widget_activate")]
    fn activate(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_activate(self.as_ref().to_glib_none().0)) }
    }

    /// Activates an action for the widget.
    ///
    /// The action is looked up in the action groups associated with
    /// @self and its ancestors.
    ///
    /// If the action is in an action group added with
    /// [`insert_action_group()`][Self::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 [`ActionExtManual::parameter_type()`][crate::gio::prelude::ActionExtManual::parameter_type()].
    /// ## `name`
    /// the name of the action to activate
    /// ## `args`
    /// parameters to use
    ///
    /// # Returns
    ///
    /// true if the action was activated
    #[doc(alias = "gtk_widget_activate_action_variant")]
    #[doc(alias = "activate_action_variant")]
    fn activate_action(
        &self,
        name: &str,
        args: Option<&glib::Variant>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gtk_widget_activate_action_variant(
                    self.as_ref().to_glib_none().0,
                    name.to_glib_none().0,
                    args.to_glib_none().0
                ),
                "Action does not exist"
            )
        }
    }

    /// Activates the `default.activate` action for the widget.
    ///
    /// The action is looked up in the same was as for
    /// `Gtk::Widget::activate_action()`.
    #[doc(alias = "gtk_widget_activate_default")]
    fn activate_default(&self) {
        unsafe {
            ffi::gtk_widget_activate_default(self.as_ref().to_glib_none().0);
        }
    }

    /// 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 [`EventController`][crate::EventController].
    /// ## `controller`
    /// an event controller that hasn't been
    ///   added to a widget yet
    #[doc(alias = "gtk_widget_add_controller")]
    fn add_controller(&self, controller: impl IsA<EventController>) {
        unsafe {
            ffi::gtk_widget_add_controller(
                self.as_ref().to_glib_none().0,
                controller.upcast().into_glib_ptr(),
            );
        }
    }

    /// 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 [`remove_css_class()`][Self::remove_css_class()] to remove the
    /// style again.
    /// ## `css_class`
    /// style class to add to @self, without the leading period
    #[doc(alias = "gtk_widget_add_css_class")]
    fn add_css_class(&self, css_class: &str) {
        unsafe {
            ffi::gtk_widget_add_css_class(
                self.as_ref().to_glib_none().0,
                css_class.to_glib_none().0,
            );
        }
    }

    /// Adds a widget to the list of mnemonic labels for this widget.
    ///
    /// See [`list_mnemonic_labels()`][Self::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.
    /// ## `label`
    /// a widget that acts as a mnemonic label for @self
    #[doc(alias = "gtk_widget_add_mnemonic_label")]
    fn add_mnemonic_label(&self, label: &impl IsA<Widget>) {
        unsafe {
            ffi::gtk_widget_add_mnemonic_label(
                self.as_ref().to_glib_none().0,
                label.as_ref().to_glib_none().0,
            );
        }
    }

    /// 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
    /// [`size_allocate()`][Self::size_allocate()].
    /// ## `width`
    /// new width
    /// ## `height`
    /// new height
    /// ## `baseline`
    /// new baseline, or -1
    /// ## `transform`
    /// transformation to be applied
    #[doc(alias = "gtk_widget_allocate")]
    fn allocate(&self, width: i32, height: i32, baseline: i32, transform: Option<gsk::Transform>) {
        unsafe {
            ffi::gtk_widget_allocate(
                self.as_ref().to_glib_none().0,
                width,
                height,
                baseline,
                transform.into_glib_ptr(),
            );
        }
    }

    /// 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 [`WidgetImpl::focus()`][crate::subclass::prelude::WidgetImpl::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
    /// [`grab_focus()`][Self::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 [`grab_focus()`][Self::grab_focus()] to move
    /// the focus to a particular widget.
    /// ## `direction`
    /// direction of focus movement
    ///
    /// # Returns
    ///
    /// true if focus ended up inside @self
    #[doc(alias = "gtk_widget_child_focus")]
    fn child_focus(&self, direction: DirectionType) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_child_focus(
                self.as_ref().to_glib_none().0,
                direction.into_glib(),
            ))
        }
    }

    /// Computes the bounds for @self 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](coordinates.html)
    /// overview to learn more.
    ///
    /// If the operation is successful, true is returned. If @self 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 @self and @target to be the same widget.
    /// ## `target`
    /// the target widget
    ///
    /// # Returns
    ///
    /// true if the bounds could be computed
    ///
    /// ## `out_bounds`
    /// the rectangle taking the bounds
    #[doc(alias = "gtk_widget_compute_bounds")]
    fn compute_bounds(&self, target: &impl IsA<Widget>) -> Option<graphene::Rect> {
        unsafe {
            let mut out_bounds = graphene::Rect::uninitialized();
            let ret = from_glib(ffi::gtk_widget_compute_bounds(
                self.as_ref().to_glib_none().0,
                target.as_ref().to_glib_none().0,
                out_bounds.to_glib_none_mut().0,
            ));
            if ret { Some(out_bounds) } else { None }
        }
    }

    /// Computes whether a parent widget should give this widget
    /// extra space when possible.
    ///
    /// Widgets with children should check this, rather than looking at
    /// [`hexpands()`][Self::hexpands()] or [`vexpands()`][Self::vexpands()].
    ///
    /// 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.
    /// ## `orientation`
    /// expand direction
    ///
    /// # Returns
    ///
    /// whether widget tree rooted here should be expanded
    #[doc(alias = "gtk_widget_compute_expand")]
    fn compute_expand(&self, orientation: Orientation) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_compute_expand(
                self.as_ref().to_glib_none().0,
                orientation.into_glib(),
            ))
        }
    }

    /// Translates the given @point in @self'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.
    /// ## `target`
    /// the widget to transform into
    /// ## `point`
    /// a point in @self's coordinate system
    ///
    /// # Returns
    ///
    /// true if @src_widget and @dest_widget have a common
    ///   ancestor, false otherwise
    ///
    /// ## `out_point`
    /// set to the corresponding coordinates in
    ///   @target's coordinate system
    #[doc(alias = "gtk_widget_compute_point")]
    fn compute_point(
        &self,
        target: &impl IsA<Widget>,
        point: &graphene::Point,
    ) -> Option<graphene::Point> {
        unsafe {
            let mut out_point = graphene::Point::uninitialized();
            let ret = from_glib(ffi::gtk_widget_compute_point(
                self.as_ref().to_glib_none().0,
                target.as_ref().to_glib_none().0,
                point.to_glib_none().0,
                out_point.to_glib_none_mut().0,
            ));
            if ret { Some(out_point) } else { None }
        }
    }

    /// Computes a matrix suitable to describe a transformation from
    /// @self's coordinate system into @target's coordinate system.
    ///
    /// The transform can not be computed in certain cases, for example
    /// when @self 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](coordinates.html).
    /// ## `target`
    /// the target widget that the matrix will transform to
    ///
    /// # Returns
    ///
    /// true if the transform could be computed
    ///
    /// ## `out_transform`
    /// location to
    ///   store the final transformation
    #[doc(alias = "gtk_widget_compute_transform")]
    fn compute_transform(&self, target: &impl IsA<Widget>) -> Option<graphene::Matrix> {
        unsafe {
            let mut out_transform = graphene::Matrix::uninitialized();
            let ret = from_glib(ffi::gtk_widget_compute_transform(
                self.as_ref().to_glib_none().0,
                target.as_ref().to_glib_none().0,
                out_transform.to_glib_none_mut().0,
            ));
            if ret { Some(out_transform) } else { None }
        }
    }

    /// 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 @self's content area.
    /// ## `x`
    /// X coordinate to test, relative to @self's origin
    /// ## `y`
    /// Y coordinate to test, relative to @self's origin
    ///
    /// # Returns
    ///
    /// true if @self contains the point (x, y)
    #[doc(alias = "gtk_widget_contains")]
    fn contains(&self, x: f64, y: f64) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_contains(
                self.as_ref().to_glib_none().0,
                x,
                y,
            ))
        }
    }

    /// Creates a new [`pango::Context`][crate::pango::Context] that is configured for the widget.
    ///
    /// The [`pango::Context`][crate::pango::Context] will have the appropriate font map,
    /// font options, font description, and base direction set.
    ///
    /// See also [`pango_context()`][Self::pango_context()].
    ///
    /// # Returns
    ///
    /// the new [`pango::Context`][crate::pango::Context]
    #[doc(alias = "gtk_widget_create_pango_context")]
    fn create_pango_context(&self) -> pango::Context {
        unsafe {
            from_glib_full(ffi::gtk_widget_create_pango_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Creates a new [`pango::Layout`][crate::pango::Layout] that is configured for the widget.
    ///
    /// The [`pango::Layout`][crate::pango::Layout] will have the appropriate font map,
    /// font description, and base direction set.
    ///
    /// If you keep a [`pango::Layout`][crate::pango::Layout] created in this way around,
    /// you need to re-create it when the widgets [`pango::Context`][crate::pango::Context]
    /// is replaced. This can be tracked by listening to changes
    /// of the [`root`][struct@crate::Widget#root] property on the widget.
    /// ## `text`
    /// text to set on the layout
    ///
    /// # Returns
    ///
    /// the new [`pango::Layout`][crate::pango::Layout]
    #[doc(alias = "gtk_widget_create_pango_layout")]
    fn create_pango_layout(&self, text: Option<&str>) -> pango::Layout {
        unsafe {
            from_glib_full(ffi::gtk_widget_create_pango_layout(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
            ))
        }
    }

    /// Checks to see if a drag movement has passed the GTK drag threshold.
    /// ## `start_x`
    /// X coordinate of start of drag
    /// ## `start_y`
    /// Y coordinate of start of drag
    /// ## `current_x`
    /// current X coordinate
    /// ## `current_y`
    /// current Y coordinate
    ///
    /// # Returns
    ///
    /// true if the drag threshold has been passed
    #[doc(alias = "gtk_drag_check_threshold")]
    fn drag_check_threshold(
        &self,
        start_x: i32,
        start_y: i32,
        current_x: i32,
        current_y: i32,
    ) -> bool {
        unsafe {
            from_glib(ffi::gtk_drag_check_threshold(
                self.as_ref().to_glib_none().0,
                start_x,
                start_y,
                current_x,
                current_y,
            ))
        }
    }

    /// Notifies the user about an input-related error on the widget.
    ///
    /// If the [`gtk-error-bell`][struct@crate::Settings#gtk-error-bell] setting is true,
    /// it calls `Gdk::Surface::beep()`, otherwise it does nothing.
    ///
    /// Note that the effect of `Gdk::Surface::beep()` can be configured
    /// in many ways, depending on the windowing backend and the desktop
    /// environment or window manager that is used.
    #[doc(alias = "gtk_widget_error_bell")]
    fn error_bell(&self) {
        unsafe {
            ffi::gtk_widget_error_bell(self.as_ref().to_glib_none().0);
        }
    }

    /// Returns the baseline that has currently been allocated to the widget.
    ///
    /// This function is intended to be used when implementing handlers
    /// for the [`Widget`][crate::Widget]Class.snapshot() function, and when allocating
    /// child widgets in [`Widget`][crate::Widget]Class.size_allocate().
    ///
    /// # Deprecated since 4.12
    ///
    /// Use [`baseline()`][Self::baseline()] instead
    ///
    /// # Returns
    ///
    /// the baseline of the @self, or -1 if none
    #[cfg_attr(feature = "v4_12", deprecated = "Since 4.12")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_get_allocated_baseline")]
    #[doc(alias = "get_allocated_baseline")]
    fn allocated_baseline(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_allocated_baseline(self.as_ref().to_glib_none().0) }
    }

    /// Returns the height that has currently been allocated to the widget.
    ///
    /// To learn more about widget sizes, see the coordinate
    /// system [overview](coordinates.html).
    ///
    /// # Deprecated since 4.12
    ///
    /// Use [`height()`][Self::height()] instead
    ///
    /// # Returns
    ///
    /// the height of the @self
    #[cfg_attr(feature = "v4_12", deprecated = "Since 4.12")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_get_allocated_height")]
    #[doc(alias = "get_allocated_height")]
    fn allocated_height(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_allocated_height(self.as_ref().to_glib_none().0) }
    }

    /// Returns the width that has currently been allocated to the widget.
    ///
    /// To learn more about widget sizes, see the coordinate
    /// system [overview](coordinates.html).
    ///
    /// # Deprecated since 4.12
    ///
    /// Use [`width()`][Self::width()] instead
    ///
    /// # Returns
    ///
    /// the width of the @self
    #[cfg_attr(feature = "v4_12", deprecated = "Since 4.12")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_get_allocated_width")]
    #[doc(alias = "get_allocated_width")]
    fn allocated_width(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_allocated_width(self.as_ref().to_glib_none().0) }
    }

    /// 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 [`size_allocate()`][Self::size_allocate()] with an allocation,
    /// and that allocation is then adjusted (to handle margin
    /// and alignment for example) before assignment to the widget.
    /// [`allocation()`][Self::allocation()] returns the adjusted allocation that
    /// was actually assigned to the widget. The adjusted allocation is
    /// guaranteed to be completely contained within the
    /// [`size_allocate()`][Self::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.
    ///
    /// # Deprecated since 4.12
    ///
    /// Use [`compute_bounds()`][Self::compute_bounds()],
    /// [`width()`][Self::width()] or [`height()`][Self::height()] instead.
    ///
    /// # Returns
    ///
    ///
    /// ## `allocation`
    /// a pointer to a `GtkAllocation` to copy to
    #[cfg_attr(feature = "v4_12", deprecated = "Since 4.12")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_get_allocation")]
    #[doc(alias = "get_allocation")]
    fn allocation(&self) -> Allocation {
        unsafe {
            let mut allocation = Allocation::uninitialized();
            ffi::gtk_widget_get_allocation(
                self.as_ref().to_glib_none().0,
                allocation.to_glib_none_mut().0,
            );
            allocation
        }
    }

    /// Gets the first ancestor of the widget with type @widget_type.
    ///
    /// For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
    /// gets the first [`Box`][crate::Box] that’s an ancestor of @self. No
    /// reference will be added to the returned widget; it should
    /// not be unreferenced.
    ///
    /// Note that unlike [`is_ancestor()`][Self::is_ancestor()], this function
    /// considers @self to be an ancestor of itself.
    /// ## `widget_type`
    /// ancestor type
    ///
    /// # Returns
    ///
    /// the ancestor widget
    #[doc(alias = "gtk_widget_get_ancestor")]
    #[doc(alias = "get_ancestor")]
    #[must_use]
    fn ancestor(&self, widget_type: glib::types::Type) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_ancestor(
                self.as_ref().to_glib_none().0,
                widget_type.into_glib(),
            ))
        }
    }

    /// 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()`.
    ///
    /// # Returns
    ///
    /// the baseline of the @self, or -1 if none
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "gtk_widget_get_baseline")]
    #[doc(alias = "get_baseline")]
    fn baseline(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_baseline(self.as_ref().to_glib_none().0) }
    }

    /// Determines whether the input focus can enter the widget or any
    /// of its children.
    ///
    /// See [`set_can_focus()`][Self::set_can_focus()].
    ///
    /// # Returns
    ///
    /// true if the input focus can enter @self
    #[doc(alias = "gtk_widget_get_can_focus")]
    #[doc(alias = "get_can_focus")]
    #[doc(alias = "can-focus")]
    fn can_focus(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_can_focus(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries whether the widget can be the target of pointer events.
    ///
    /// # Returns
    ///
    /// true if @self can receive pointer events
    #[doc(alias = "gtk_widget_get_can_target")]
    #[doc(alias = "get_can_target")]
    #[doc(alias = "can-target")]
    fn can_target(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_can_target(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value set with [`set_child_visible()`][Self::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.
    ///
    /// # Returns
    ///
    /// true if the widget is mapped with the parent
    #[doc(alias = "gtk_widget_get_child_visible")]
    #[doc(alias = "get_child_visible")]
    fn is_child_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_child_visible(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the clipboard object for the widget.
    ///
    /// This is a utility function to get the clipboard object for the
    /// display that @self is using.
    ///
    /// Note that this function always works, even when @self is not
    /// realized yet.
    ///
    /// # Returns
    ///
    /// the appropriate clipboard object
    #[doc(alias = "gtk_widget_get_clipboard")]
    #[doc(alias = "get_clipboard")]
    fn clipboard(&self) -> gdk::Clipboard {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_clipboard(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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.
    ///
    /// # Returns
    ///
    ///
    /// ## `color`
    /// return location for the color
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    #[doc(alias = "gtk_widget_get_color")]
    #[doc(alias = "get_color")]
    fn color(&self) -> gdk::RGBA {
        unsafe {
            let mut color = gdk::RGBA::uninitialized();
            ffi::gtk_widget_get_color(self.as_ref().to_glib_none().0, color.to_glib_none_mut().0);
            color
        }
    }

    /// Returns the list of style classes applied to the widget.
    ///
    /// # Returns
    ///
    /// a `NULL`-terminated list of
    ///   css classes currently applied to @self
    #[doc(alias = "gtk_widget_get_css_classes")]
    #[doc(alias = "get_css_classes")]
    #[doc(alias = "css-classes")]
    fn css_classes(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_widget_get_css_classes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the CSS name of the widget.
    ///
    /// # Returns
    ///
    /// the CSS name
    #[doc(alias = "gtk_widget_get_css_name")]
    #[doc(alias = "get_css_name")]
    #[doc(alias = "css-name")]
    fn css_name(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::gtk_widget_get_css_name(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the cursor set on the widget.
    ///
    /// See [`set_cursor()`][Self::set_cursor()] for details.
    ///
    /// # Returns
    ///
    /// the cursor
    ///   that is set on @self
    #[doc(alias = "gtk_widget_get_cursor")]
    #[doc(alias = "get_cursor")]
    fn cursor(&self) -> Option<gdk::Cursor> {
        unsafe { from_glib_none(ffi::gtk_widget_get_cursor(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the reading direction for the widget.
    ///
    /// See [`set_direction()`][Self::set_direction()].
    ///
    /// # Returns
    ///
    /// the reading direction for the widget
    #[doc(alias = "gtk_widget_get_direction")]
    #[doc(alias = "get_direction")]
    fn direction(&self) -> TextDirection {
        unsafe {
            from_glib(ffi::gtk_widget_get_direction(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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 [`Root`][crate::Root] 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.
    ///
    /// # Returns
    ///
    /// the display for this widget
    #[doc(alias = "gtk_widget_get_display")]
    #[doc(alias = "get_display")]
    fn display(&self) -> gdk::Display {
        unsafe { from_glib_none(ffi::gtk_widget_get_display(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the widget’s first child.
    ///
    /// This function is primarily meant for widget implementations.
    ///
    /// # Returns
    ///
    /// the widget's first child
    #[doc(alias = "gtk_widget_get_first_child")]
    #[doc(alias = "get_first_child")]
    #[must_use]
    fn first_child(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_first_child(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the focus child of the widget.
    ///
    /// # Returns
    ///
    /// the current focus
    ///   child of @self
    #[doc(alias = "gtk_widget_get_focus_child")]
    #[doc(alias = "get_focus_child")]
    #[must_use]
    fn focus_child(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_focus_child(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the widget should grab focus when it is clicked
    /// with the mouse.
    ///
    /// See [`set_focus_on_click()`][Self::set_focus_on_click()].
    ///
    /// # Returns
    ///
    /// true if the widget should grab focus when it is
    ///   clicked with the mouse
    #[doc(alias = "gtk_widget_get_focus_on_click")]
    #[doc(alias = "get_focus_on_click")]
    #[doc(alias = "focus-on-click")]
    fn gets_focus_on_click(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_focus_on_click(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether the widget can own the input focus.
    ///
    /// See [`set_focusable()`][Self::set_focusable()].
    ///
    /// # Returns
    ///
    /// true if @self can own the input focus
    #[doc(alias = "gtk_widget_get_focusable")]
    #[doc(alias = "get_focusable")]
    #[doc(alias = "focusable")]
    fn is_focusable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_focusable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the font map of the widget.
    ///
    /// See [`set_font_map()`][Self::set_font_map()].
    ///
    /// # Returns
    ///
    /// the font map of @self
    #[doc(alias = "gtk_widget_get_font_map")]
    #[doc(alias = "get_font_map")]
    fn font_map(&self) -> Option<pango::FontMap> {
        unsafe { from_glib_none(ffi::gtk_widget_get_font_map(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the [`cairo::FontOptions`][crate::cairo::FontOptions] of the widget.
    ///
    /// Seee [`set_font_options()`][Self::set_font_options()].
    ///
    /// # Deprecated since 4.16
    ///
    ///
    /// # Returns
    ///
    /// the [`cairo::FontOptions`][crate::cairo::FontOptions] of widget
    #[cfg_attr(feature = "v4_16", deprecated = "Since 4.16")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_get_font_options")]
    #[doc(alias = "get_font_options")]
    fn font_options(&self) -> Option<cairo::FontOptions> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_font_options(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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 [`FrameClock::frame_time()`][crate::gdk::FrameClock::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
    /// [`FrameClock::frame_time()`][crate::gdk::FrameClock::frame_time()], and then update the animation
    /// by calling [`FrameClock::frame_time()`][crate::gdk::FrameClock::frame_time()] again during each repaint.
    ///
    /// [`FrameClock::request_phase()`][crate::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 [`queue_draw()`][Self::queue_draw()] which invalidates the
    /// widget (thus scheduling it to receive a draw on the next frame).
    /// [`queue_draw()`][Self::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.
    ///
    /// # Returns
    ///
    /// the frame clock
    #[doc(alias = "gtk_widget_get_frame_clock")]
    #[doc(alias = "get_frame_clock")]
    fn frame_clock(&self) -> Option<gdk::FrameClock> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_frame_clock(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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.
    ///
    /// # Returns
    ///
    /// the horizontal alignment of @self
    #[doc(alias = "gtk_widget_get_halign")]
    #[doc(alias = "get_halign")]
    fn halign(&self) -> Align {
        unsafe { from_glib(ffi::gtk_widget_get_halign(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the current value of the `has-tooltip` property.
    ///
    /// # Returns
    ///
    /// current value of `has-tooltip` on @self
    #[doc(alias = "gtk_widget_get_has_tooltip")]
    #[doc(alias = "get_has_tooltip")]
    #[doc(alias = "has-tooltip")]
    fn has_tooltip(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_has_tooltip(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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 [`WidgetImpl::snapshot()`][crate::subclass::prelude::WidgetImpl::snapshot()].
    ///
    /// For pointer events, see [`contains()`][Self::contains()].
    ///
    /// To learn more about widget sizes, see the coordinate
    /// system [overview](coordinates.html).
    ///
    /// # Returns
    ///
    /// The height of @self
    #[doc(alias = "gtk_widget_get_height")]
    #[doc(alias = "get_height")]
    fn height(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_height(self.as_ref().to_glib_none().0) }
    }

    /// 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 [`compute_expand()`][Self::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.
    ///
    /// # Returns
    ///
    /// whether hexpand flag is set
    #[doc(alias = "gtk_widget_get_hexpand")]
    #[doc(alias = "get_hexpand")]
    #[doc(alias = "hexpand")]
    fn hexpands(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_hexpand(self.as_ref().to_glib_none().0)) }
    }

    /// Gets whether the `hexpand` flag has been explicitly set.
    ///
    /// If [`hexpand`][struct@crate::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.
    ///
    /// # Returns
    ///
    /// whether hexpand has been explicitly set
    #[doc(alias = "gtk_widget_get_hexpand_set")]
    #[doc(alias = "get_hexpand_set")]
    #[doc(alias = "hexpand-set")]
    fn is_hexpand_set(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_hexpand_set(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the widget’s last child.
    ///
    /// This function is primarily meant for widget implementations.
    ///
    /// # Returns
    ///
    /// the widget's last child
    #[doc(alias = "gtk_widget_get_last_child")]
    #[doc(alias = "get_last_child")]
    #[must_use]
    fn last_child(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_last_child(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves the layout manager of the widget.
    ///
    /// See [`set_layout_manager()`][Self::set_layout_manager()].
    ///
    /// # Returns
    ///
    /// the layout manager of @self
    #[doc(alias = "gtk_widget_get_layout_manager")]
    #[doc(alias = "get_layout_manager")]
    #[doc(alias = "layout-manager")]
    fn layout_manager(&self) -> Option<LayoutManager> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_layout_manager(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value of the [`limit-events`][struct@crate::Widget#limit-events] property.
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "gtk_widget_get_limit_events")]
    #[doc(alias = "get_limit_events")]
    #[doc(alias = "limit-events")]
    fn is_limit_events(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_limit_events(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the widget is mapped.
    ///
    /// # Returns
    ///
    /// true if the widget is mapped
    #[doc(alias = "gtk_widget_get_mapped")]
    #[doc(alias = "get_mapped")]
    fn is_mapped(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_mapped(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the bottom margin of the widget.
    ///
    /// # Returns
    ///
    /// The bottom margin of @self
    #[doc(alias = "gtk_widget_get_margin_bottom")]
    #[doc(alias = "get_margin_bottom")]
    #[doc(alias = "margin-bottom")]
    fn margin_bottom(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_margin_bottom(self.as_ref().to_glib_none().0) }
    }

    /// Gets the end margin of the widget.
    ///
    /// # Returns
    ///
    /// The end margin of @self
    #[doc(alias = "gtk_widget_get_margin_end")]
    #[doc(alias = "get_margin_end")]
    #[doc(alias = "margin-end")]
    fn margin_end(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_margin_end(self.as_ref().to_glib_none().0) }
    }

    /// Gets the start margin of the widget.
    ///
    /// # Returns
    ///
    /// The start margin of @self
    #[doc(alias = "gtk_widget_get_margin_start")]
    #[doc(alias = "get_margin_start")]
    #[doc(alias = "margin-start")]
    fn margin_start(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_margin_start(self.as_ref().to_glib_none().0) }
    }

    /// Gets the top margin of the widget.
    ///
    /// # Returns
    ///
    /// The top margin of @self
    #[doc(alias = "gtk_widget_get_margin_top")]
    #[doc(alias = "get_margin_top")]
    #[doc(alias = "margin-top")]
    fn margin_top(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_margin_top(self.as_ref().to_glib_none().0) }
    }

    /// Retrieves the name of a widget.
    ///
    /// See [`set_widget_name()`][Self::set_widget_name()] for the significance of widget names.
    ///
    /// # Returns
    ///
    /// name of the widget
    #[doc(alias = "gtk_widget_get_name")]
    #[doc(alias = "get_name")]
    #[doc(alias = "name")]
    fn widget_name(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::gtk_widget_get_name(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the nearest [`Native`][crate::Native] ancestor of the widget.
    ///
    /// This function will return `NULL` if the widget is not
    /// contained inside a widget tree with a native ancestor.
    ///
    /// [`Native`][crate::Native] widgets will return themselves here.
    ///
    /// # Returns
    ///
    /// the [`Native`][crate::Native] ancestor of @self
    #[doc(alias = "gtk_widget_get_native")]
    #[doc(alias = "get_native")]
    fn native(&self) -> Option<Native> {
        unsafe { from_glib_none(ffi::gtk_widget_get_native(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the widget’s next sibling.
    ///
    /// This function is primarily meant for widget implementations.
    ///
    /// # Returns
    ///
    /// the widget's next sibling
    #[doc(alias = "gtk_widget_get_next_sibling")]
    #[doc(alias = "get_next_sibling")]
    #[must_use]
    fn next_sibling(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_next_sibling(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Fetches the requested opacity for the widget.
    ///
    /// See [`set_opacity()`][Self::set_opacity()].
    ///
    /// # Returns
    ///
    /// the requested opacity for this widget
    #[doc(alias = "gtk_widget_get_opacity")]
    #[doc(alias = "get_opacity")]
    fn opacity(&self) -> f64 {
        unsafe { ffi::gtk_widget_get_opacity(self.as_ref().to_glib_none().0) }
    }

    /// Returns the widget’s overflow value.
    ///
    /// # Returns
    ///
    /// The widget's overflow value
    #[doc(alias = "gtk_widget_get_overflow")]
    #[doc(alias = "get_overflow")]
    fn overflow(&self) -> Overflow {
        unsafe { from_glib(ffi::gtk_widget_get_overflow(self.as_ref().to_glib_none().0)) }
    }

    /// Gets a [`pango::Context`][crate::pango::Context] that is configured for the widget.
    ///
    /// The [`pango::Context`][crate::pango::Context] will have the appropriate font map, font description,
    /// and base direction set.
    ///
    /// Unlike the context returned by [`create_pango_context()`][Self::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
    /// [`root`][struct@crate::Widget#root] property on the widget.
    ///
    /// # Returns
    ///
    /// the [`pango::Context`][crate::pango::Context] for the widget
    #[doc(alias = "gtk_widget_get_pango_context")]
    #[doc(alias = "get_pango_context")]
    fn pango_context(&self) -> pango::Context {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_pango_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the parent widget of the widget.
    ///
    /// # Returns
    ///
    /// the parent widget of @self
    #[doc(alias = "gtk_widget_get_parent")]
    #[doc(alias = "get_parent")]
    #[must_use]
    fn parent(&self) -> Option<Widget> {
        unsafe { from_glib_none(ffi::gtk_widget_get_parent(self.as_ref().to_glib_none().0)) }
    }

    /// 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 [`Fixed`][crate::Fixed].
    ///
    /// 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 [`measure()`][Self::measure()] if you want to support baseline alignment.
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_size`
    /// location for storing the minimum size
    ///
    /// ## `natural_size`
    /// location for storing the natural size
    #[doc(alias = "gtk_widget_get_preferred_size")]
    #[doc(alias = "get_preferred_size")]
    fn preferred_size(&self) -> (Requisition, Requisition) {
        unsafe {
            let mut minimum_size = Requisition::uninitialized();
            let mut natural_size = Requisition::uninitialized();
            ffi::gtk_widget_get_preferred_size(
                self.as_ref().to_glib_none().0,
                minimum_size.to_glib_none_mut().0,
                natural_size.to_glib_none_mut().0,
            );
            (minimum_size, natural_size)
        }
    }

    /// Returns the widget’s previous sibling.
    ///
    /// This function is primarily meant for widget implementations.
    ///
    /// # Returns
    ///
    /// the widget's previous sibling
    #[doc(alias = "gtk_widget_get_prev_sibling")]
    #[doc(alias = "get_prev_sibling")]
    #[must_use]
    fn prev_sibling(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_prev_sibling(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the primary clipboard of the widget.
    ///
    /// This is a utility function to get the primary clipboard object
    /// for the display that @self is using.
    ///
    /// Note that this function always works, even when @self is not
    /// realized yet.
    ///
    /// # Returns
    ///
    /// the appropriate clipboard object
    #[doc(alias = "gtk_widget_get_primary_clipboard")]
    #[doc(alias = "get_primary_clipboard")]
    fn primary_clipboard(&self) -> gdk::Clipboard {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_primary_clipboard(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether the widget is realized.
    ///
    /// # Returns
    ///
    /// true if @self is realized
    #[doc(alias = "gtk_widget_get_realized")]
    #[doc(alias = "get_realized")]
    fn is_realized(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_realized(self.as_ref().to_glib_none().0)) }
    }

    /// 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 [`set_receives_default()`][Self::set_receives_default()].
    ///
    /// # Returns
    ///
    /// true if @self acts as the default widget when focused
    #[doc(alias = "gtk_widget_get_receives_default")]
    #[doc(alias = "get_receives_default")]
    #[doc(alias = "receives-default")]
    fn receives_default(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_receives_default(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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.
    ///
    /// # Returns
    ///
    /// The [`SizeRequestMode`][crate::SizeRequestMode] preferred by @self.
    #[doc(alias = "gtk_widget_get_request_mode")]
    #[doc(alias = "get_request_mode")]
    fn request_mode(&self) -> SizeRequestMode {
        unsafe {
            from_glib(ffi::gtk_widget_get_request_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the [`Root`][crate::Root] widget of the widget.
    ///
    /// This function will return `NULL` if the widget is not contained
    /// inside a widget tree with a root widget.
    ///
    /// [`Root`][crate::Root] widgets will return themselves here.
    ///
    /// # Returns
    ///
    /// the root widget of @self
    #[doc(alias = "gtk_widget_get_root")]
    #[doc(alias = "get_root")]
    fn root(&self) -> Option<Root> {
        unsafe { from_glib_none(ffi::gtk_widget_get_root(self.as_ref().to_glib_none().0)) }
    }

    /// 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 `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 [`SurfaceExtManual::scale()`][crate::gdk::prelude::SurfaceExtManual::scale()]
    /// to get the fractional scale value.
    ///
    /// # Returns
    ///
    /// the scale factor for @self
    #[doc(alias = "gtk_widget_get_scale_factor")]
    #[doc(alias = "get_scale_factor")]
    #[doc(alias = "scale-factor")]
    fn scale_factor(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_scale_factor(self.as_ref().to_glib_none().0) }
    }

    /// Returns the widget’s sensitivity.
    ///
    /// This function returns the value that has been set using
    /// [`set_sensitive()`][Self::set_sensitive()]).
    ///
    /// The effective sensitivity of a widget is however determined
    /// by both its own and its parent widget’s sensitivity.
    /// See [`is_sensitive()`][Self::is_sensitive()].
    ///
    /// # Returns
    ///
    /// true if the widget is sensitive
    #[doc(alias = "gtk_widget_get_sensitive")]
    #[doc(alias = "sensitive")]
    fn get_sensitive(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_sensitive(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the settings object holding the settings used for the widget.
    ///
    /// Note that this function can only be called when the [`Widget`][crate::Widget]
    /// 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.
    ///
    /// # Returns
    ///
    /// the relevant settings object
    #[doc(alias = "gtk_widget_get_settings")]
    #[doc(alias = "get_settings")]
    fn settings(&self) -> Settings {
        unsafe { from_glib_none(ffi::gtk_widget_get_settings(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the content width or height of the widget.
    ///
    /// Which dimension is returned depends on @orientation.
    ///
    /// This is equivalent to calling [`width()`][Self::width()]
    /// for [enum@Gtk.Orientation.horizontal] or [`height()`][Self::height()]
    /// for [enum@Gtk.Orientation.vertical], but can be used when
    /// writing orientation-independent code, such as when
    /// implementing [`Orientable`][crate::Orientable] widgets.
    ///
    /// To learn more about widget sizes, see the coordinate
    /// system [overview](coordinates.html).
    /// ## `orientation`
    /// the orientation to query
    ///
    /// # Returns
    ///
    /// the size of @self in @orientation
    #[doc(alias = "gtk_widget_get_size")]
    #[doc(alias = "get_size")]
    fn size(&self, orientation: Orientation) -> i32 {
        unsafe { ffi::gtk_widget_get_size(self.as_ref().to_glib_none().0, orientation.into_glib()) }
    }

    /// 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 [`set_size_request()`][Self::set_size_request()].
    ///
    /// To get the size a widget will actually request, call
    /// [`measure()`][Self::measure()] instead of this function.
    ///
    /// # Returns
    ///
    ///
    /// ## `width`
    /// return location for width
    ///
    /// ## `height`
    /// return location for height
    #[doc(alias = "gtk_widget_get_size_request")]
    #[doc(alias = "get_size_request")]
    fn size_request(&self) -> (i32, i32) {
        unsafe {
            let mut width = std::mem::MaybeUninit::uninit();
            let mut height = std::mem::MaybeUninit::uninit();
            ffi::gtk_widget_get_size_request(
                self.as_ref().to_glib_none().0,
                width.as_mut_ptr(),
                height.as_mut_ptr(),
            );
            (width.assume_init(), height.assume_init())
        }
    }

    /// 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 @self itself is sensitive.
    ///
    /// Also note that if you are looking for a way to obtain the
    /// [`StateFlags`][crate::StateFlags] to pass to a [`StyleContext`][crate::StyleContext]
    /// method, you should look at [`StyleContextExt::state()`][crate::prelude::StyleContextExt::state()].
    ///
    /// # Returns
    ///
    /// the state flags of widget
    #[doc(alias = "gtk_widget_get_state_flags")]
    #[doc(alias = "get_state_flags")]
    fn state_flags(&self) -> StateFlags {
        unsafe {
            from_glib(ffi::gtk_widget_get_state_flags(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the style context associated to the widget.
    ///
    /// The returned object is guaranteed to be the same
    /// for the lifetime of @self.
    ///
    /// # Deprecated since 4.10
    ///
    /// Style contexts will be removed in GTK 5
    ///
    /// # Returns
    ///
    /// the widgets style context
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_get_style_context")]
    #[doc(alias = "get_style_context")]
    fn style_context(&self) -> StyleContext {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_style_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the contents of the tooltip for the widget.
    ///
    /// If the tooltip has not been set using
    /// [`set_tooltip_markup()`][Self::set_tooltip_markup()], this
    /// function returns `NULL`.
    ///
    /// # Returns
    ///
    /// the tooltip text
    #[doc(alias = "gtk_widget_get_tooltip_markup")]
    #[doc(alias = "get_tooltip_markup")]
    #[doc(alias = "tooltip-markup")]
    fn tooltip_markup(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_tooltip_markup(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the contents of the tooltip for the widget.
    ///
    /// If the @self's tooltip was set using
    /// [`set_tooltip_markup()`][Self::set_tooltip_markup()],
    /// this function will return the escaped text.
    ///
    /// # Returns
    ///
    /// the tooltip text
    #[doc(alias = "gtk_widget_get_tooltip_text")]
    #[doc(alias = "get_tooltip_text")]
    #[doc(alias = "tooltip-text")]
    fn tooltip_text(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_tooltip_text(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the vertical alignment of the widget.
    ///
    /// # Returns
    ///
    /// the vertical alignment of @self
    #[doc(alias = "gtk_widget_get_valign")]
    #[doc(alias = "get_valign")]
    fn valign(&self) -> Align {
        unsafe { from_glib(ffi::gtk_widget_get_valign(self.as_ref().to_glib_none().0)) }
    }

    /// Gets whether the widget would like any available extra vertical
    /// space.
    ///
    /// See [`hexpands()`][Self::hexpands()] for more detail.
    ///
    /// # Returns
    ///
    /// whether vexpand flag is set
    #[doc(alias = "gtk_widget_get_vexpand")]
    #[doc(alias = "get_vexpand")]
    #[doc(alias = "vexpand")]
    fn vexpands(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_vexpand(self.as_ref().to_glib_none().0)) }
    }

    /// Gets whether the `vexpand` flag has been explicitly set.
    ///
    /// See [`is_hexpand_set()`][Self::is_hexpand_set()] for more detail.
    ///
    /// # Returns
    ///
    /// whether vexpand has been explicitly set
    #[doc(alias = "gtk_widget_get_vexpand_set")]
    #[doc(alias = "get_vexpand_set")]
    #[doc(alias = "vexpand-set")]
    fn is_vexpand_set(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_vexpand_set(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether the widget is visible.
    ///
    /// If you want to take into account whether the widget’s
    /// parent is also marked as visible, use
    /// [`is_visible()`][Self::is_visible()] instead.
    ///
    /// This function does not check if the widget is
    /// obscured in any way.
    ///
    /// See [`set_visible()`][Self::set_visible()].
    ///
    /// # Returns
    ///
    /// true if the widget is visible
    #[doc(alias = "gtk_widget_get_visible")]
    #[doc(alias = "visible")]
    fn get_visible(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_visible(self.as_ref().to_glib_none().0)) }
    }

    /// 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 [`WidgetImpl::snapshot()`][crate::subclass::prelude::WidgetImpl::snapshot()].
    ///
    /// For pointer events, see [`contains()`][Self::contains()].
    ///
    /// To learn more about widget sizes, see the coordinate
    /// system [overview](coordinates.html).
    ///
    /// # Returns
    ///
    /// The width of @self
    #[doc(alias = "gtk_widget_get_width")]
    #[doc(alias = "get_width")]
    fn width(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_width(self.as_ref().to_glib_none().0) }
    }

    /// Causes @self to have the keyboard focus for the window
    /// that it belongs to.
    ///
    /// If @self is not focusable, or its [`WidgetImpl::grab_focus()`][crate::subclass::prelude::WidgetImpl::grab_focus()]
    /// implementation cannot transfer the focus to a descendant of @self
    /// that is focusable, it will not take focus and false will be returned.
    ///
    /// Calling [`grab_focus()`][Self::grab_focus()] on an already focused widget
    /// is allowed, should not have an effect, and return true.
    ///
    /// # Returns
    ///
    /// true if focus is now inside @self
    #[doc(alias = "gtk_widget_grab_focus")]
    fn grab_focus(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_grab_focus(self.as_ref().to_glib_none().0)) }
    }

    /// Returns whether a style class is currently applied to the widget.
    /// ## `css_class`
    /// style class, without the leading period
    ///
    /// # Returns
    ///
    /// true if @css_class is currently applied to @self
    #[doc(alias = "gtk_widget_has_css_class")]
    fn has_css_class(&self, css_class: &str) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_has_css_class(
                self.as_ref().to_glib_none().0,
                css_class.to_glib_none().0,
            ))
        }
    }

    /// Determines whether the widget is the current default widget
    /// within its toplevel.
    ///
    /// # Returns
    ///
    /// true if @self is the current default widget
    ///   within its toplevel
    #[doc(alias = "gtk_widget_has_default")]
    #[doc(alias = "has-default")]
    fn has_default(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_has_default(self.as_ref().to_glib_none().0)) }
    }

    /// Determines if the widget has the global input focus.
    ///
    /// See [`is_focus()`][Self::is_focus()] for the difference between
    /// having the global input focus, and only having the focus
    /// within a toplevel.
    ///
    /// # Returns
    ///
    /// true if the widget has the global input focus
    #[doc(alias = "gtk_widget_has_focus")]
    #[doc(alias = "has-focus")]
    fn has_focus(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_has_focus(self.as_ref().to_glib_none().0)) }
    }

    /// 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 @self. See [`GtkWindowExt::gets_focus_visible()`][crate::prelude::GtkWindowExt::gets_focus_visible()] for more
    /// information about focus indication.
    ///
    /// To find out if the widget has the global input focus, use
    /// [`has_focus()`][Self::has_focus()].
    ///
    /// # Returns
    ///
    /// true if the widget should display a “focus rectangle”
    #[doc(alias = "gtk_widget_has_visible_focus")]
    fn has_visible_focus(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_has_visible_focus(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Reverses the effects of [method.Gtk.Widget.show].
    ///
    /// This is causing the widget to be hidden (invisible to the user).
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`set_visible()`][Self::set_visible()] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_hide")]
    fn hide(&self) {
        unsafe {
            ffi::gtk_widget_hide(self.as_ref().to_glib_none().0);
        }
    }

    /// Returns whether the widget is currently being destroyed.
    ///
    /// This information can sometimes be used to avoid doing
    /// unnecessary work.
    ///
    /// # Returns
    ///
    /// true if @self is being destroyed
    #[doc(alias = "gtk_widget_in_destruction")]
    fn in_destruction(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_in_destruction(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Inserts an action group into the widget's actions.
    ///
    /// Children of @self that implement [`Actionable`][crate::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 @self.
    /// ## `name`
    /// the prefix for actions in @group
    /// ## `group`
    /// an action group
    #[doc(alias = "gtk_widget_insert_action_group")]
    fn insert_action_group(&self, name: &str, group: Option<&impl IsA<gio::ActionGroup>>) {
        unsafe {
            ffi::gtk_widget_insert_action_group(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                group.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the parent widget of the widget.
    ///
    /// In contrast to [`set_parent()`][Self::set_parent()], this function
    /// inserts @self 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 @self, this
    /// function can also be used to reorder @self 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.
    /// ## `parent`
    /// the parent widget to insert @self into
    /// ## `previous_sibling`
    /// the new previous sibling of @self
    #[doc(alias = "gtk_widget_insert_after")]
    fn insert_after(&self, parent: &impl IsA<Widget>, previous_sibling: Option<&impl IsA<Widget>>) {
        unsafe {
            ffi::gtk_widget_insert_after(
                self.as_ref().to_glib_none().0,
                parent.as_ref().to_glib_none().0,
                previous_sibling.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the parent widget of the widget.
    ///
    /// In contrast to [`set_parent()`][Self::set_parent()], this function
    /// inserts @self 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 @self, this function
    /// can also be used to reorder @self 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.
    /// ## `parent`
    /// the parent widget to insert @self into
    /// ## `next_sibling`
    /// the new next sibling of @self
    #[doc(alias = "gtk_widget_insert_before")]
    fn insert_before(&self, parent: &impl IsA<Widget>, next_sibling: Option<&impl IsA<Widget>>) {
        unsafe {
            ffi::gtk_widget_insert_before(
                self.as_ref().to_glib_none().0,
                parent.as_ref().to_glib_none().0,
                next_sibling.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Determines whether the widget is a descendent of @ancestor.
    /// ## `ancestor`
    /// another [`Widget`][crate::Widget]
    ///
    /// # Returns
    ///
    /// true if @ancestor contains @self as a child,
    ///   grandchild, great grandchild, etc
    #[doc(alias = "gtk_widget_is_ancestor")]
    fn is_ancestor(&self, ancestor: &impl IsA<Widget>) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_is_ancestor(
                self.as_ref().to_glib_none().0,
                ancestor.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether the widget can be drawn to.
    ///
    /// A widget can be drawn if it is mapped and visible.
    ///
    /// # Returns
    ///
    /// true if @self is drawable
    #[doc(alias = "gtk_widget_is_drawable")]
    fn is_drawable(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_is_drawable(self.as_ref().to_glib_none().0)) }
    }

    /// Determines if the widget is the focus widget within its
    /// toplevel.
    ///
    /// This does not mean that the [`has-focus`][struct@crate::Widget#has-focus]
    /// property is necessarily set; [`has-focus`][struct@crate::Widget#has-focus]
    /// will only be set if the toplevel widget additionally has the
    /// global input focus.
    ///
    /// # Returns
    ///
    /// true if the widget is the focus widget
    #[doc(alias = "gtk_widget_is_focus")]
    fn is_focus(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_is_focus(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the widget’s effective sensitivity.
    ///
    /// This means it is sensitive itself and also its
    /// parent widget is sensitive.
    ///
    /// # Returns
    ///
    /// true if the widget is effectively sensitive
    #[doc(alias = "gtk_widget_is_sensitive")]
    fn is_sensitive(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_is_sensitive(self.as_ref().to_glib_none().0)) }
    }

    /// 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 [`get_visible()`][Self::get_visible()] and
    /// [`set_visible()`][Self::set_visible()].
    ///
    /// # Returns
    ///
    /// true if the widget and all its parents are visible
    #[doc(alias = "gtk_widget_is_visible")]
    fn is_visible(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_is_visible(self.as_ref().to_glib_none().0)) }
    }

    /// Emits the [`keynav-failed`][struct@crate::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
    /// [`child_focus()`][Self::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
    /// [`child_focus()`][Self::child_focus()] on the widget’s toplevel.
    ///
    /// The default [`keynav-failed`][struct@crate::Widget#keynav-failed] handler returns
    /// false for [enum@Gtk.DirectionType.tab-forward] and
    /// [enum@Gtk.DirectionType.tab-backward]. For the other values
    /// of [`DirectionType`][crate::DirectionType] it returns true.
    ///
    /// Whenever the default handler returns true, it also calls
    /// [`error_bell()`][Self::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
    /// [`Entry`][crate::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.
    /// ## `direction`
    /// direction of focus movement
    ///
    /// # Returns
    ///
    /// true if stopping keyboard navigation is fine, false
    ///   if the emitting widget should try to handle the keyboard
    ///   navigation attempt in its parent widget
    #[doc(alias = "gtk_widget_keynav_failed")]
    fn keynav_failed(&self, direction: DirectionType) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_keynav_failed(
                self.as_ref().to_glib_none().0,
                direction.into_glib(),
            ))
        }
    }

    /// Returns the widgets for which this widget is the target of a
    /// mnemonic.
    ///
    /// Typically, these widgets will be labels. See, for example,
    /// [`Label::set_mnemonic_widget()`][crate::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.
    ///
    /// # Returns
    ///
    /// the list
    ///   of mnemonic labels
    #[doc(alias = "gtk_widget_list_mnemonic_labels")]
    fn list_mnemonic_labels(&self) -> Vec<Widget> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_widget_list_mnemonic_labels(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Causes a widget to be mapped if it isn’t already.
    ///
    /// This function is only for use in widget implementations.
    #[doc(alias = "gtk_widget_map")]
    fn map(&self) {
        unsafe {
            ffi::gtk_widget_map(self.as_ref().to_glib_none().0);
        }
    }

    /// Measures @self in the orientation @orientation and for the given @for_size.
    ///
    /// As an example, if @orientation is [`Orientation::Horizontal`][crate::Orientation::Horizontal] and @for_size
    /// is 300, this functions will compute the minimum and natural width of @self
    /// if it is allocated at a height of 300 pixels.
    ///
    /// See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
    /// a more details on implementing `GtkWidgetClass.measure()`.
    /// ## `orientation`
    /// the orientation to measure
    /// ## `for_size`
    /// Size for the opposite of @orientation, i.e.
    ///   if @orientation is [`Orientation::Horizontal`][crate::Orientation::Horizontal], this is
    ///   the height the widget should be measured with. The [`Orientation::Vertical`][crate::Orientation::Vertical]
    ///   case is analogous. This way, both height-for-width and width-for-height
    ///   requests can be implemented. If no size is known, -1 can be passed.
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum`
    /// location to store the minimum size
    ///
    /// ## `natural`
    /// location to store the natural size
    ///
    /// ## `minimum_baseline`
    /// location to store the baseline
    ///   position for the minimum size, or -1 to report no baseline
    ///
    /// ## `natural_baseline`
    /// location to store the baseline
    ///   position for the natural size, or -1 to report no baseline
    #[doc(alias = "gtk_widget_measure")]
    fn measure(&self, orientation: Orientation, for_size: i32) -> (i32, i32, i32, i32) {
        unsafe {
            let mut minimum = std::mem::MaybeUninit::uninit();
            let mut natural = std::mem::MaybeUninit::uninit();
            let mut minimum_baseline = std::mem::MaybeUninit::uninit();
            let mut natural_baseline = std::mem::MaybeUninit::uninit();
            ffi::gtk_widget_measure(
                self.as_ref().to_glib_none().0,
                orientation.into_glib(),
                for_size,
                minimum.as_mut_ptr(),
                natural.as_mut_ptr(),
                minimum_baseline.as_mut_ptr(),
                natural_baseline.as_mut_ptr(),
            );
            (
                minimum.assume_init(),
                natural.assume_init(),
                minimum_baseline.assume_init(),
                natural_baseline.assume_init(),
            )
        }
    }

    /// Emits the [`mnemonic-activate`][struct@crate::Widget#mnemonic-activate] signal.
    /// ## `group_cycling`
    /// true if there are other widgets with the same mnemonic
    ///
    /// # Returns
    ///
    /// true if the signal has been handled
    #[doc(alias = "gtk_widget_mnemonic_activate")]
    fn mnemonic_activate(&self, group_cycling: bool) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_mnemonic_activate(
                self.as_ref().to_glib_none().0,
                group_cycling.into_glib(),
            ))
        }
    }

    /// 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.
    ///
    /// # Returns
    ///
    ///
    ///   a list model tracking @self's children
    #[doc(alias = "gtk_widget_observe_children")]
    fn observe_children(&self) -> gio::ListModel {
        unsafe {
            from_glib_full(ffi::gtk_widget_observe_children(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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.
    ///
    /// # Returns
    ///
    ///
    ///   a list model tracking @self's controllers
    #[doc(alias = "gtk_widget_observe_controllers")]
    fn observe_controllers(&self) -> gio::ListModel {
        unsafe {
            from_glib_full(ffi::gtk_widget_observe_controllers(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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 @self's content area.
    ///
    /// Usually widgets will return `NULL` if the given coordinate is not
    /// contained in @self checked via [`contains()`][Self::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.
    /// ## `x`
    /// x coordinate to test, relative to @self's origin
    /// ## `y`
    /// y coordinate to test, relative to @self's origin
    /// ## `flags`
    /// flags to influence what is picked
    ///
    /// # Returns
    ///
    /// the widget's descendant at (x, y)
    #[doc(alias = "gtk_widget_pick")]
    #[must_use]
    fn pick(&self, x: f64, y: f64, flags: PickFlags) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_widget_pick(
                self.as_ref().to_glib_none().0,
                x,
                y,
                flags.into_glib(),
            ))
        }
    }

    /// Flags the widget for a rerun of the [`WidgetImpl::size_allocate()`][crate::subclass::prelude::WidgetImpl::size_allocate()]
    /// function.
    ///
    /// Use this function instead of [`queue_resize()`][Self::queue_resize()]
    /// when the @self's size request didn't change but it wants to
    /// reposition its contents.
    ///
    /// An example user of this function is [`set_halign()`][Self::set_halign()].
    ///
    /// This function is only for use in widget implementations.
    #[doc(alias = "gtk_widget_queue_allocate")]
    fn queue_allocate(&self) {
        unsafe {
            ffi::gtk_widget_queue_allocate(self.as_ref().to_glib_none().0);
        }
    }

    /// Schedules this widget to be redrawn.
    ///
    /// The redraw will happen in the paint phase
    /// of the current or the next frame.
    ///
    /// This means @self's [`WidgetImpl::snapshot()`][crate::subclass::prelude::WidgetImpl::snapshot()]
    /// implementation will be called.
    #[doc(alias = "gtk_widget_queue_draw")]
    fn queue_draw(&self) {
        unsafe {
            ffi::gtk_widget_queue_draw(self.as_ref().to_glib_none().0);
        }
    }

    /// 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
    /// [`Label`][crate::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 [`WidgetImpl::size_allocate()`][crate::subclass::prelude::WidgetImpl::size_allocate()]
    /// virtual method. Calls to gtk_widget_queue_resize() from inside
    /// [`WidgetImpl::size_allocate()`][crate::subclass::prelude::WidgetImpl::size_allocate()] will be silently ignored.
    ///
    /// This function is only for use in widget implementations.
    #[doc(alias = "gtk_widget_queue_resize")]
    fn queue_resize(&self) {
        unsafe {
            ffi::gtk_widget_queue_resize(self.as_ref().to_glib_none().0);
        }
    }

    /// 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 @self 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
    /// [`realize`][struct@crate::Widget#realize].
    #[doc(alias = "gtk_widget_realize")]
    fn realize(&self) {
        unsafe {
            ffi::gtk_widget_realize(self.as_ref().to_glib_none().0);
        }
    }

    /// 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.
    /// ## `controller`
    /// an event controller
    #[doc(alias = "gtk_widget_remove_controller")]
    fn remove_controller(&self, controller: &impl IsA<EventController>) {
        unsafe {
            ffi::gtk_widget_remove_controller(
                self.as_ref().to_glib_none().0,
                controller.as_ref().to_glib_none().0,
            );
        }
    }

    /// Removes a style from the widget.
    ///
    /// After this, the style of @self will stop matching for @css_class.
    /// ## `css_class`
    /// style class to remove from @self, without the leading period
    #[doc(alias = "gtk_widget_remove_css_class")]
    fn remove_css_class(&self, css_class: &str) {
        unsafe {
            ffi::gtk_widget_remove_css_class(
                self.as_ref().to_glib_none().0,
                css_class.to_glib_none().0,
            );
        }
    }

    /// Removes a widget from the list of mnemonic labels for this widget.
    ///
    /// See [`list_mnemonic_labels()`][Self::list_mnemonic_labels()].
    ///
    /// The widget must have previously been added to the list with
    /// [`add_mnemonic_label()`][Self::add_mnemonic_label()].
    /// ## `label`
    /// a widget that is a mnemonic label for @self
    #[doc(alias = "gtk_widget_remove_mnemonic_label")]
    fn remove_mnemonic_label(&self, label: &impl IsA<Widget>) {
        unsafe {
            ffi::gtk_widget_remove_mnemonic_label(
                self.as_ref().to_glib_none().0,
                label.as_ref().to_glib_none().0,
            );
        }
    }

    /// 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 [`grab_focus()`][Self::grab_focus()] for actually setting
    /// the input focus on a widget.
    /// ## `can_focus`
    /// whether the input focus can enter
    ///   the widget or any of its children
    #[doc(alias = "gtk_widget_set_can_focus")]
    #[doc(alias = "can-focus")]
    fn set_can_focus(&self, can_focus: bool) {
        unsafe {
            ffi::gtk_widget_set_can_focus(self.as_ref().to_glib_none().0, can_focus.into_glib());
        }
    }

    /// Sets whether the widget can be the target of pointer events.
    /// ## `can_target`
    /// whether this widget should be able to
    ///   receive pointer events
    #[doc(alias = "gtk_widget_set_can_target")]
    #[doc(alias = "can-target")]
    fn set_can_target(&self, can_target: bool) {
        unsafe {
            ffi::gtk_widget_set_can_target(self.as_ref().to_glib_none().0, can_target.into_glib());
        }
    }

    /// 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 [`set_parent()`][Self::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.
    /// ## `child_visible`
    /// whether @self should be mapped along
    ///   with its parent
    #[doc(alias = "gtk_widget_set_child_visible")]
    fn set_child_visible(&self, child_visible: bool) {
        unsafe {
            ffi::gtk_widget_set_child_visible(
                self.as_ref().to_glib_none().0,
                child_visible.into_glib(),
            );
        }
    }

    /// Replaces the current style classes of the widget with @classes.
    /// ## `classes`
    ///
    ///   `NULL`-terminated list of style classes
    #[doc(alias = "gtk_widget_set_css_classes")]
    #[doc(alias = "css-classes")]
    fn set_css_classes(&self, classes: &[&str]) {
        unsafe {
            ffi::gtk_widget_set_css_classes(
                self.as_ref().to_glib_none().0,
                classes.to_glib_none().0,
            );
        }
    }

    /// Sets the cursor to be shown when the pointer hovers over
    /// the widget.
    ///
    /// If the @cursor is `NULL`, @self will use the cursor
    /// inherited from its parent.
    /// ## `cursor`
    /// the new cursor
    #[doc(alias = "gtk_widget_set_cursor")]
    #[doc(alias = "cursor")]
    fn set_cursor(&self, cursor: Option<&gdk::Cursor>) {
        unsafe {
            ffi::gtk_widget_set_cursor(self.as_ref().to_glib_none().0, cursor.to_glib_none().0);
        }
    }

    /// Sets the cursor to be shown when the pointer hovers over
    /// the widget.
    ///
    /// This is a utility function that creates a cursor via
    /// [`gdk::Cursor::from_name()`][crate::gdk::Cursor::from_name()] and then sets it on @self
    /// with [`set_cursor()`][Self::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 [`set_cursor()`][Self::set_cursor()]
    /// with a `NULL` cursor.
    /// ## `name`
    /// the name of the cursor
    #[doc(alias = "gtk_widget_set_cursor_from_name")]
    fn set_cursor_from_name(&self, name: Option<&str>) {
        unsafe {
            ffi::gtk_widget_set_cursor_from_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            );
        }
    }

    /// 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 [`Widget::set_default_direction()`][crate::Widget::set_default_direction()] will be used.
    /// ## `dir`
    /// the new direction
    #[doc(alias = "gtk_widget_set_direction")]
    fn set_direction(&self, dir: TextDirection) {
        unsafe {
            ffi::gtk_widget_set_direction(self.as_ref().to_glib_none().0, dir.into_glib());
        }
    }

    /// 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
    /// [`grab_focus()`][Self::grab_focus()] on it.
    /// ## `child`
    /// a direct child widget of @self
    ///   or `NULL` to unset the focus child
    #[doc(alias = "gtk_widget_set_focus_child")]
    fn set_focus_child(&self, child: Option<&impl IsA<Widget>>) {
        unsafe {
            ffi::gtk_widget_set_focus_child(
                self.as_ref().to_glib_none().0,
                child.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// 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.
    /// ## `focus_on_click`
    /// whether the widget should grab focus when clicked
    ///   with the mouse
    #[doc(alias = "gtk_widget_set_focus_on_click")]
    #[doc(alias = "focus-on-click")]
    fn set_focus_on_click(&self, focus_on_click: bool) {
        unsafe {
            ffi::gtk_widget_set_focus_on_click(
                self.as_ref().to_glib_none().0,
                focus_on_click.into_glib(),
            );
        }
    }

    /// 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 [`grab_focus()`][Self::grab_focus()] for actually setting
    /// the input focus on a widget.
    /// ## `focusable`
    /// whether or not @self can own the input focus
    #[doc(alias = "gtk_widget_set_focusable")]
    #[doc(alias = "focusable")]
    fn set_focusable(&self, focusable: bool) {
        unsafe {
            ffi::gtk_widget_set_focusable(self.as_ref().to_glib_none().0, focusable.into_glib());
        }
    }

    /// 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.
    /// ## `font_map`
    /// a [`pango::FontMap`][crate::pango::FontMap]
    #[doc(alias = "gtk_widget_set_font_map")]
    fn set_font_map(&self, font_map: Option<&impl IsA<pango::FontMap>>) {
        unsafe {
            ffi::gtk_widget_set_font_map(
                self.as_ref().to_glib_none().0,
                font_map.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the [`cairo::FontOptions`][crate::cairo::FontOptions] used for text rendering
    /// in the widget.
    ///
    /// When not set, the default font options for the [`gdk::Display`][crate::gdk::Display]
    /// will be used.
    ///
    /// # Deprecated since 4.16
    ///
    /// ## `options`
    /// a [`cairo::FontOptions`][crate::cairo::FontOptions] struct
    ///   to unset any previously set default font options
    #[cfg_attr(feature = "v4_16", deprecated = "Since 4.16")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_set_font_options")]
    fn set_font_options(&self, options: Option<&cairo::FontOptions>) {
        unsafe {
            ffi::gtk_widget_set_font_options(
                self.as_ref().to_glib_none().0,
                options.to_glib_none().0,
            );
        }
    }

    /// Sets the horizontal alignment of the widget.
    /// ## `align`
    /// the horizontal alignment
    #[doc(alias = "gtk_widget_set_halign")]
    #[doc(alias = "halign")]
    fn set_halign(&self, align: Align) {
        unsafe {
            ffi::gtk_widget_set_halign(self.as_ref().to_glib_none().0, align.into_glib());
        }
    }

    /// Sets the `has-tooltip` property on the widget.
    /// ## `has_tooltip`
    /// whether or not @self has a tooltip
    #[doc(alias = "gtk_widget_set_has_tooltip")]
    #[doc(alias = "has-tooltip")]
    fn set_has_tooltip(&self, has_tooltip: bool) {
        unsafe {
            ffi::gtk_widget_set_has_tooltip(
                self.as_ref().to_glib_none().0,
                has_tooltip.into_glib(),
            );
        }
    }

    /// 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 [`compute_expand()`][Self::compute_expand()].
    /// A widget can decide how the expandability of children affects its
    /// own expansion by overriding the `compute_expand` virtual method on
    /// [`Widget`][crate::Widget].).
    ///
    /// 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
    /// [`set_hexpand()`][Self::set_hexpand()] sets the hexpand-set property (see
    /// [`set_hexpand_set()`][Self::set_hexpand_set()]) which causes the widget’s hexpand
    /// value to be used, rather than looking at children and widget state.
    /// ## `expand`
    /// whether to expand
    #[doc(alias = "gtk_widget_set_hexpand")]
    #[doc(alias = "hexpand")]
    fn set_hexpand(&self, expand: bool) {
        unsafe {
            ffi::gtk_widget_set_hexpand(self.as_ref().to_glib_none().0, expand.into_glib());
        }
    }

    /// Sets whether the hexpand flag will be used.
    ///
    /// The [`hexpand-set`][struct@crate::Widget#hexpand-set] property will be set
    /// automatically when you call [`set_hexpand()`][Self::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.
    /// ## `set`
    /// value for hexpand-set property
    #[doc(alias = "gtk_widget_set_hexpand_set")]
    #[doc(alias = "hexpand-set")]
    fn set_hexpand_set(&self, set: bool) {
        unsafe {
            ffi::gtk_widget_set_hexpand_set(self.as_ref().to_glib_none().0, set.into_glib());
        }
    }

    /// Sets the layout manager to use for measuring and allocating children
    /// of the widget.
    /// ## `layout_manager`
    /// a layout manager
    #[doc(alias = "gtk_widget_set_layout_manager")]
    #[doc(alias = "layout-manager")]
    fn set_layout_manager(&self, layout_manager: Option<impl IsA<LayoutManager>>) {
        unsafe {
            ffi::gtk_widget_set_layout_manager(
                self.as_ref().to_glib_none().0,
                layout_manager.map(|p| p.upcast()).into_glib_ptr(),
            );
        }
    }

    /// Sets whether the widget acts like a modal dialog,
    /// with respect to event delivery.
    /// ## `limit_events`
    /// whether to limit events
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "gtk_widget_set_limit_events")]
    #[doc(alias = "limit-events")]
    fn set_limit_events(&self, limit_events: bool) {
        unsafe {
            ffi::gtk_widget_set_limit_events(
                self.as_ref().to_glib_none().0,
                limit_events.into_glib(),
            );
        }
    }

    /// Sets the bottom margin of the widget.
    /// ## `margin`
    /// the bottom margin
    #[doc(alias = "gtk_widget_set_margin_bottom")]
    #[doc(alias = "margin-bottom")]
    fn set_margin_bottom(&self, margin: i32) {
        unsafe {
            ffi::gtk_widget_set_margin_bottom(self.as_ref().to_glib_none().0, margin);
        }
    }

    /// Sets the end margin of the widget.
    /// ## `margin`
    /// the end margin
    #[doc(alias = "gtk_widget_set_margin_end")]
    #[doc(alias = "margin-end")]
    fn set_margin_end(&self, margin: i32) {
        unsafe {
            ffi::gtk_widget_set_margin_end(self.as_ref().to_glib_none().0, margin);
        }
    }

    /// Sets the start margin of the widget.
    /// ## `margin`
    /// the start margin
    #[doc(alias = "gtk_widget_set_margin_start")]
    #[doc(alias = "margin-start")]
    fn set_margin_start(&self, margin: i32) {
        unsafe {
            ffi::gtk_widget_set_margin_start(self.as_ref().to_glib_none().0, margin);
        }
    }

    /// Sets the top margin of the widget.
    /// ## `margin`
    /// the top margin
    #[doc(alias = "gtk_widget_set_margin_top")]
    #[doc(alias = "margin-top")]
    fn set_margin_top(&self, margin: i32) {
        unsafe {
            ffi::gtk_widget_set_margin_top(self.as_ref().to_glib_none().0, margin);
        }
    }

    /// 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 [`StyleContext`][crate::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.
    /// ## `name`
    /// name for the widget
    #[doc(alias = "gtk_widget_set_name")]
    #[doc(alias = "set_name")]
    #[doc(alias = "name")]
    fn set_widget_name(&self, name: &str) {
        unsafe {
            ffi::gtk_widget_set_name(self.as_ref().to_glib_none().0, name.to_glib_none().0);
        }
    }

    /// 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
    /// `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, [`Popover`][crate::Popover]
    /// instances and other [`Native`][crate::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.
    /// ## `opacity`
    /// desired opacity, between 0 and 1
    #[doc(alias = "gtk_widget_set_opacity")]
    #[doc(alias = "opacity")]
    fn set_opacity(&self, opacity: f64) {
        unsafe {
            ffi::gtk_widget_set_opacity(self.as_ref().to_glib_none().0, opacity);
        }
    }

    /// Sets how the widget treats content that is drawn outside the
    /// it's content area.
    ///
    /// See the definition of [`Overflow`][crate::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].
    /// ## `overflow`
    /// desired overflow value
    #[doc(alias = "gtk_widget_set_overflow")]
    #[doc(alias = "overflow")]
    fn set_overflow(&self, overflow: Overflow) {
        unsafe {
            ffi::gtk_widget_set_overflow(self.as_ref().to_glib_none().0, overflow.into_glib());
        }
    }

    /// 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 [`unparent()`][Self::unparent()].
    ///
    /// This function is useful only when implementing subclasses of
    /// [`Widget`][crate::Widget].
    /// ## `parent`
    /// parent widget
    #[doc(alias = "gtk_widget_set_parent")]
    fn set_parent(&self, parent: &impl IsA<Widget>) {
        unsafe {
            ffi::gtk_widget_set_parent(
                self.as_ref().to_glib_none().0,
                parent.as_ref().to_glib_none().0,
            );
        }
    }

    /// 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.
    /// ## `receives_default`
    /// whether or not @self can be a default widget
    #[doc(alias = "gtk_widget_set_receives_default")]
    #[doc(alias = "receives-default")]
    fn set_receives_default(&self, receives_default: bool) {
        unsafe {
            ffi::gtk_widget_set_receives_default(
                self.as_ref().to_glib_none().0,
                receives_default.into_glib(),
            );
        }
    }

    /// 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.
    /// ## `sensitive`
    /// true to make the widget sensitive
    #[doc(alias = "gtk_widget_set_sensitive")]
    #[doc(alias = "sensitive")]
    fn set_sensitive(&self, sensitive: bool) {
        unsafe {
            ffi::gtk_widget_set_sensitive(self.as_ref().to_glib_none().0, sensitive.into_glib());
        }
    }

    /// 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, [`GtkWindowExt::set_default_size()`][crate::prelude::GtkWindowExt::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
    /// [`margin-start`][struct@crate::Widget#margin-start],
    /// [`margin-end`][struct@crate::Widget#margin-end],
    /// [`margin-top`][struct@crate::Widget#margin-top], and
    /// [`margin-bottom`][struct@crate::Widget#margin-bottom], but it does include pretty
    /// much all other padding or border properties set by any subclass
    /// of [`Widget`][crate::Widget].
    /// ## `width`
    /// width @self should request, or -1 to unset
    /// ## `height`
    /// height @self should request, or -1 to unset
    #[doc(alias = "gtk_widget_set_size_request")]
    fn set_size_request(&self, width: i32, height: i32) {
        unsafe {
            ffi::gtk_widget_set_size_request(self.as_ref().to_glib_none().0, width, height);
        }
    }

    /// 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 [`set_direction()`][Self::set_direction()].
    ///
    /// This function is for use in widget implementations.
    /// ## `flags`
    /// state flags to turn on
    /// ## `clear`
    /// whether to clear state before turning on @flags
    #[doc(alias = "gtk_widget_set_state_flags")]
    fn set_state_flags(&self, flags: StateFlags, clear: bool) {
        unsafe {
            ffi::gtk_widget_set_state_flags(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                clear.into_glib(),
            );
        }
    }

    /// Sets the contents of the tooltip for widget.
    ///
    /// @markup must contain Pango markup.
    ///
    /// This function will take care of setting the
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] as a side effect, and of the
    /// default handler for the [`query-tooltip`][struct@crate::Widget#query-tooltip] signal.
    ///
    /// See also [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    /// ## `markup`
    /// the contents of the tooltip for @self
    #[doc(alias = "gtk_widget_set_tooltip_markup")]
    #[doc(alias = "tooltip-markup")]
    fn set_tooltip_markup(&self, markup: Option<&str>) {
        unsafe {
            ffi::gtk_widget_set_tooltip_markup(
                self.as_ref().to_glib_none().0,
                markup.to_glib_none().0,
            );
        }
    }

    /// 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
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] as a side effect,
    /// and of the default handler for the
    /// [`query-tooltip`][struct@crate::Widget#query-tooltip] signal.
    ///
    /// See also [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    /// ## `text`
    /// the contents of the tooltip for @self
    #[doc(alias = "gtk_widget_set_tooltip_text")]
    #[doc(alias = "tooltip-text")]
    fn set_tooltip_text(&self, text: Option<&str>) {
        unsafe {
            ffi::gtk_widget_set_tooltip_text(self.as_ref().to_glib_none().0, text.to_glib_none().0);
        }
    }

    /// Sets the vertical alignment of the widget.
    /// ## `align`
    /// the vertical alignment
    #[doc(alias = "gtk_widget_set_valign")]
    #[doc(alias = "valign")]
    fn set_valign(&self, align: Align) {
        unsafe {
            ffi::gtk_widget_set_valign(self.as_ref().to_glib_none().0, align.into_glib());
        }
    }

    /// Sets whether the widget would like any available extra vertical
    /// space.
    ///
    /// See [`set_hexpand()`][Self::set_hexpand()] for more detail.
    /// ## `expand`
    /// whether to expand
    #[doc(alias = "gtk_widget_set_vexpand")]
    #[doc(alias = "vexpand")]
    fn set_vexpand(&self, expand: bool) {
        unsafe {
            ffi::gtk_widget_set_vexpand(self.as_ref().to_glib_none().0, expand.into_glib());
        }
    }

    /// Sets whether the vexpand flag will be used.
    ///
    /// See [`set_hexpand_set()`][Self::set_hexpand_set()] for more detail.
    /// ## `set`
    /// value for vexpand-set property
    #[doc(alias = "gtk_widget_set_vexpand_set")]
    #[doc(alias = "vexpand-set")]
    fn set_vexpand_set(&self, set: bool) {
        unsafe {
            ffi::gtk_widget_set_vexpand_set(self.as_ref().to_glib_none().0, set.into_glib());
        }
    }

    /// Sets the visibility state of @self.
    ///
    /// Note that setting this to true doesn’t mean the widget is
    /// actually viewable, see [`get_visible()`][Self::get_visible()].
    /// ## `visible`
    /// whether the widget should be shown or not
    #[doc(alias = "gtk_widget_set_visible")]
    #[doc(alias = "visible")]
    fn set_visible(&self, visible: bool) {
        unsafe {
            ffi::gtk_widget_set_visible(self.as_ref().to_glib_none().0, visible.into_glib());
        }
    }

    /// 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 [`Popover`][crate::Popover] instances.
    ///
    /// # Returns
    ///
    /// true if child should be included in
    ///   measuring and allocating
    #[doc(alias = "gtk_widget_should_layout")]
    fn should_layout(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_should_layout(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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.
    ///
    /// # Deprecated since 4.10
    ///
    /// Use [`set_visible()`][Self::set_visible()] instead
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_show")]
    fn show(&self) {
        unsafe {
            ffi::gtk_widget_show(self.as_ref().to_glib_none().0);
        }
    }

    /// Allocates widget with a transformation that translates
    /// the origin to the position in @allocation.
    ///
    /// This is a simple form of [`allocate()`][Self::allocate()].
    /// ## `allocation`
    /// position and size to be allocated to @self
    /// ## `baseline`
    /// the baseline of the child, or -1
    #[doc(alias = "gtk_widget_size_allocate")]
    fn size_allocate(&self, allocation: &Allocation, baseline: i32) {
        unsafe {
            ffi::gtk_widget_size_allocate(
                self.as_ref().to_glib_none().0,
                allocation.to_glib_none().0,
                baseline,
            );
        }
    }

    /// Snapshots a child of the widget.
    ///
    /// When a widget receives a call to the snapshot function,
    /// it must send synthetic [`WidgetImpl::snapshot()`][crate::subclass::prelude::WidgetImpl::snapshot()] calls
    /// to all children. This function provides a convenient way
    /// of doing this. A widget, when it receives a call to its
    /// [`WidgetImpl::snapshot()`][crate::subclass::prelude::WidgetImpl::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 [`Native`][crate::Native].
    /// ## `child`
    /// a child of @self
    /// ## `snapshot`
    /// snapshot as passed to the widget. In particular, no
    ///   calls to [`SnapshotExt::translate()`][crate::prelude::SnapshotExt::translate()] or other transform calls
    ///   should have been made
    #[doc(alias = "gtk_widget_snapshot_child")]
    fn snapshot_child(&self, child: &impl IsA<Widget>, snapshot: &impl IsA<Snapshot>) {
        unsafe {
            ffi::gtk_widget_snapshot_child(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                snapshot.as_ref().to_glib_none().0,
            );
        }
    }

    /// Translates coordinates relative to @self’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.
    ///
    /// # Deprecated since 4.12
    ///
    /// Use [`compute_point()`][Self::compute_point()] instead
    /// ## `dest_widget`
    /// another widget
    /// ## `src_x`
    /// X position in widget coordinates of @self
    /// ## `src_y`
    /// Y position in widget coordinates of @self
    ///
    /// # Returns
    ///
    /// true if @self and @dest_widget have a common
    ///   ancestor, false otherwise
    ///
    /// ## `dest_x`
    /// location to store X position in widget coordinates of @dest_widget
    ///
    /// ## `dest_y`
    /// location to store Y position in widget coordinates of @dest_widget
    #[cfg_attr(feature = "v4_12", deprecated = "Since 4.12")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_widget_translate_coordinates")]
    fn translate_coordinates(
        &self,
        dest_widget: &impl IsA<Widget>,
        src_x: f64,
        src_y: f64,
    ) -> Option<(f64, f64)> {
        unsafe {
            let mut dest_x = std::mem::MaybeUninit::uninit();
            let mut dest_y = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_widget_translate_coordinates(
                self.as_ref().to_glib_none().0,
                dest_widget.as_ref().to_glib_none().0,
                src_x,
                src_y,
                dest_x.as_mut_ptr(),
                dest_y.as_mut_ptr(),
            ));
            if ret {
                Some((dest_x.assume_init(), dest_y.assume_init()))
            } else {
                None
            }
        }
    }

    /// Triggers a tooltip query on the display of the widget.
    #[doc(alias = "gtk_widget_trigger_tooltip_query")]
    fn trigger_tooltip_query(&self) {
        unsafe {
            ffi::gtk_widget_trigger_tooltip_query(self.as_ref().to_glib_none().0);
        }
    }

    /// Causes a widget to be unmapped if it’s currently mapped.
    ///
    /// This function is only for use in widget implementations.
    #[doc(alias = "gtk_widget_unmap")]
    fn unmap(&self) {
        unsafe {
            ffi::gtk_widget_unmap(self.as_ref().to_glib_none().0);
        }
    }

    /// Removes @self from its parent.
    ///
    /// This function is only for use in widget implementations,
    /// typically in dispose.
    #[doc(alias = "gtk_widget_unparent")]
    fn unparent(&self) {
        unsafe {
            ffi::gtk_widget_unparent(self.as_ref().to_glib_none().0);
        }
    }

    /// Causes a widget to be unrealized.
    ///
    /// This frees all GDK resources associated with the widget.
    ///
    /// This function is only useful in widget implementations.
    #[doc(alias = "gtk_widget_unrealize")]
    fn unrealize(&self) {
        unsafe {
            ffi::gtk_widget_unrealize(self.as_ref().to_glib_none().0);
        }
    }

    /// Turns off flag values for the current widget state.
    ///
    /// See [`set_state_flags()`][Self::set_state_flags()].
    ///
    /// This function is for use in widget implementations.
    /// ## `flags`
    /// state flags to turn off
    #[doc(alias = "gtk_widget_unset_state_flags")]
    fn unset_state_flags(&self, flags: StateFlags) {
        unsafe {
            ffi::gtk_widget_unset_state_flags(self.as_ref().to_glib_none().0, flags.into_glib());
        }
    }

    /// Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    #[doc(alias = "height-request")]
    fn height_request(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "height-request")
    }

    /// Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    #[doc(alias = "height-request")]
    fn set_height_request(&self, height_request: i32) {
        ObjectExt::set_property(self.as_ref(), "height-request", height_request)
    }

    /// Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    #[doc(alias = "width-request")]
    fn width_request(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "width-request")
    }

    /// Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    #[doc(alias = "width-request")]
    fn set_width_request(&self, width_request: i32) {
        ObjectExt::set_property(self.as_ref(), "width-request", width_request)
    }

    /// Signals that all holders of a reference to the widget should release
    /// the reference that they hold.
    ///
    /// May result in finalization of the widget if all references are released.
    ///
    /// This signal is not suitable for saving widget state.
    #[doc(alias = "destroy")]
    fn connect_destroy<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn destroy_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"destroy".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    destroy_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the text direction of a widget changes.
    /// ## `previous_direction`
    /// the previous text direction
    #[doc(alias = "direction-changed")]
    fn connect_direction_changed<F: Fn(&Self, TextDirection) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn direction_changed_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, TextDirection) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            previous_direction: ffi::GtkTextDirection,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Widget::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(previous_direction),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"direction-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    direction_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when @widget is hidden.
    #[doc(alias = "hide")]
    fn connect_hide<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn hide_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"hide".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    hide_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted if keyboard navigation fails.
    ///
    /// See [`keynav_failed()`][Self::keynav_failed()] for details.
    /// ## `direction`
    /// the direction of movement
    ///
    /// # Returns
    ///
    /// true if stopping keyboard navigation is fine, false
    ///   if the emitting widget should try to handle the keyboard
    ///   navigation attempt in its parent widget
    #[doc(alias = "keynav-failed")]
    fn connect_keynav_failed<F: Fn(&Self, DirectionType) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn keynav_failed_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, DirectionType) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            direction: ffi::GtkDirectionType,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Widget::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(direction),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"keynav-failed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    keynav_failed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when @widget is going to be mapped.
    ///
    /// A widget is mapped when the widget is visible (which is controlled with
    /// [`visible`][struct@crate::Widget#visible]) and all its parents up to the toplevel widget
    /// are also visible.
    ///
    /// The `::map` signal can be used to determine whether a widget will be drawn,
    /// for instance it can resume an animation that was stopped during the
    /// emission of [`unmap`][struct@crate::Widget#unmap].
    #[doc(alias = "map")]
    fn connect_map<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn map_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"map".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    map_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a widget is activated via a mnemonic.
    ///
    /// The default handler for this signal activates @widget if @group_cycling
    /// is false, or just makes @widget grab focus if @group_cycling is true.
    /// ## `group_cycling`
    /// true if there are other widgets with the same mnemonic
    ///
    /// # Returns
    ///
    /// true to stop other handlers from being invoked for the event,
    ///   false to propagate the event further
    #[doc(alias = "mnemonic-activate")]
    fn connect_mnemonic_activate<F: Fn(&Self, bool) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn mnemonic_activate_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, bool) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            group_cycling: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Widget::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(group_cycling),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"mnemonic-activate".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    mnemonic_activate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the focus is moved.
    ///
    /// The `::move-focus` signal is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are <kbd>Tab</kbd> to move forward,
    /// and <kbd>Shift</kbd>+<kbd>Tab</kbd> to move backward.
    /// ## `direction`
    /// the direction of the focus move
    #[doc(alias = "move-focus")]
    fn connect_move_focus<F: Fn(&Self, DirectionType) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn move_focus_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, DirectionType) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            direction: ffi::GtkDirectionType,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Widget::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(direction),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"move-focus".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    move_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_move_focus(&self, direction: DirectionType) {
        self.emit_by_name::<()>("move-focus", &[&direction]);
    }

    /// Emitted when the widget’s tooltip is about to be shown.
    ///
    /// This happens when the [`has-tooltip`][struct@crate::Widget#has-tooltip] property
    /// is true and the hover timeout has expired with the cursor hovering
    /// above @widget; or emitted when @widget got focus in keyboard mode.
    ///
    /// Using the given coordinates, the signal handler should determine
    /// whether a tooltip should be shown for @widget. If this is the case
    /// true should be returned, false otherwise. Note that if @keyboard_mode
    /// is true, the values of @x and @y are undefined and should not be used.
    ///
    /// The signal handler is free to manipulate @tooltip with the therefore
    /// destined function calls.
    /// ## `x`
    /// the x coordinate of the cursor position in widget coordinates
    /// ## `y`
    /// the y coordinate of the cursor position in widget coordinates
    /// ## `keyboard_mode`
    /// true if the tooltip was triggered using the keyboard
    /// ## `tooltip`
    /// a [`Tooltip`][crate::Tooltip]
    ///
    /// # Returns
    ///
    /// true if @tooltip should be shown right now, false otherwise
    #[doc(alias = "query-tooltip")]
    fn connect_query_tooltip<F: Fn(&Self, i32, i32, bool, &Tooltip) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn query_tooltip_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, i32, i32, bool, &Tooltip) -> bool + 'static,
        >(
            this: *mut ffi::GtkWidget,
            x: std::ffi::c_int,
            y: std::ffi::c_int,
            keyboard_mode: glib::ffi::gboolean,
            tooltip: *mut ffi::GtkTooltip,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Widget::from_glib_borrow(this).unsafe_cast_ref(),
                    x,
                    y,
                    from_glib(keyboard_mode),
                    &from_glib_borrow(tooltip),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"query-tooltip".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    query_tooltip_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when @widget is associated with a [`gdk::Surface`][crate::gdk::Surface].
    ///
    /// This means that [`realize()`][Self::realize()] has been called
    /// or the widget has been mapped (that is, it is going to be drawn).
    #[doc(alias = "realize")]
    fn connect_realize<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn realize_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"realize".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    realize_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when @widget is shown.
    #[doc(alias = "show")]
    fn connect_show<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn show_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"show".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    show_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the widget state changes.
    ///
    /// See [`state_flags()`][Self::state_flags()].
    /// ## `flags`
    /// the previous state flags
    #[doc(alias = "state-flags-changed")]
    fn connect_state_flags_changed<F: Fn(&Self, StateFlags) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn state_flags_changed_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, StateFlags) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            flags: ffi::GtkStateFlags,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Widget::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(flags),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"state-flags-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    state_flags_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when @widget is going to be unmapped.
    ///
    /// A widget is unmapped when either it or any of its parents up to the
    /// toplevel widget have been set as hidden.
    ///
    /// As `::unmap` indicates that a widget will not be shown any longer,
    /// it can be used to, for example, stop an animation on the widget.
    #[doc(alias = "unmap")]
    fn connect_unmap<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn unmap_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"unmap".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    unmap_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the [`gdk::Surface`][crate::gdk::Surface] associated with @widget is destroyed.
    ///
    /// This means that [`unrealize()`][Self::unrealize()] has been called
    /// or the widget has been unmapped (that is, it is going to be hidden).
    #[doc(alias = "unrealize")]
    fn connect_unrealize<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn unrealize_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"unrealize".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    unrealize_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "can-focus")]
    fn connect_can_focus_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_focus_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::can-focus".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_can_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "can-target")]
    fn connect_can_target_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_target_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::can-target".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_can_target_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "css-classes")]
    fn connect_css_classes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_css_classes_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::css-classes".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_css_classes_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "cursor")]
    fn connect_cursor_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_cursor_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::cursor".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_cursor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "focus-on-click")]
    fn connect_focus_on_click_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_focus_on_click_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::focus-on-click".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_focus_on_click_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "focusable")]
    fn connect_focusable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_focusable_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::focusable".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_focusable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "halign")]
    fn connect_halign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_halign_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::halign".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_halign_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "has-default")]
    fn connect_has_default_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_default_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::has-default".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_has_default_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "has-focus")]
    fn connect_has_focus_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_focus_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::has-focus".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_has_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "has-tooltip")]
    fn connect_has_tooltip_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_tooltip_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::has-tooltip".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_has_tooltip_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "height-request")]
    fn connect_height_request_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_height_request_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::height-request".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_height_request_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "hexpand")]
    fn connect_hexpand_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_hexpand_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::hexpand".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_hexpand_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "hexpand-set")]
    fn connect_hexpand_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_hexpand_set_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::hexpand-set".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_hexpand_set_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "layout-manager")]
    fn connect_layout_manager_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_layout_manager_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::layout-manager".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_layout_manager_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "limit-events")]
    fn connect_limit_events_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_limit_events_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::limit-events".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_limit_events_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "margin-bottom")]
    fn connect_margin_bottom_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_margin_bottom_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::margin-bottom".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_margin_bottom_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "margin-end")]
    fn connect_margin_end_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_margin_end_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::margin-end".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_margin_end_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "margin-start")]
    fn connect_margin_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_margin_start_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::margin-start".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_margin_start_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "margin-top")]
    fn connect_margin_top_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_margin_top_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::margin-top".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_margin_top_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "name")]
    fn connect_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_name_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::name".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "opacity")]
    fn connect_opacity_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_opacity_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::opacity".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_opacity_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "overflow")]
    fn connect_overflow_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_overflow_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::overflow".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_overflow_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "parent")]
    fn connect_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_parent_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::parent".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_parent_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "receives-default")]
    fn connect_receives_default_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_receives_default_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::receives-default".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_receives_default_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "root")]
    fn connect_root_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_root_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::root".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_root_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "scale-factor")]
    fn connect_scale_factor_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_scale_factor_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::scale-factor".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_scale_factor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "sensitive")]
    fn connect_sensitive_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_sensitive_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::sensitive".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_sensitive_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "tooltip-markup")]
    fn connect_tooltip_markup_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_tooltip_markup_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::tooltip-markup".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_tooltip_markup_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "tooltip-text")]
    fn connect_tooltip_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_tooltip_text_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::tooltip-text".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_tooltip_text_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "valign")]
    fn connect_valign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_valign_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::valign".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_valign_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "vexpand")]
    fn connect_vexpand_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_vexpand_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::vexpand".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_vexpand_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "vexpand-set")]
    fn connect_vexpand_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_vexpand_set_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::vexpand-set".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_vexpand_set_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "visible")]
    fn connect_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_visible_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::visible".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_visible_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "width-request")]
    fn connect_width_request_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_width_request_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Widget::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::width-request".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_width_request_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Widget>> WidgetExt for O {}