gtk/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

use crate::{
    AccelFlags, AccelGroup, Align, Allocation, Buildable, Clipboard, DirectionType, DragResult,
    Orientation, Requisition, SelectionData, Settings, SizeRequestMode, StateFlags, StyleContext,
    TargetList, TextDirection, Tooltip, WidgetHelpType, WidgetPath, Window,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem, mem::transmute};

glib::wrapper! {
    /// GtkWidget is the base class all widgets in GTK+ derive from. It manages the
    /// widget lifecycle, states and style.
    ///
    /// # Height-for-width Geometry Management # {`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 five virtual methods:
    ///
    /// - `GtkWidgetClass.get_request_mode()`
    /// - `GtkWidgetClass.get_preferred_width()`
    /// - `GtkWidgetClass.get_preferred_height()`
    /// - `GtkWidgetClass.get_preferred_height_for_width()`
    /// - `GtkWidgetClass.get_preferred_width_for_height()`
    /// - `GtkWidgetClass.get_preferred_height_and_baseline_for_width()`
    ///
    /// There are some important things to keep in mind when implementing
    /// height-for-width and when using it in container implementations.
    ///
    /// 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::preferred_width()`][crate::prelude::WidgetExt::preferred_width()].
    /// Because the preferred widths for each container 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::preferred_height_for_width()`][crate::prelude::WidgetExt::preferred_height_for_width()], which 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
    /// (unless [`GtkWindowExt::set_geometry_hints()`][crate::prelude::GtkWindowExt::set_geometry_hints()] is explicitly used instead).
    ///
    /// 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 container widgets allocate their children.
    /// Each container 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`][crate::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.
    ///
    /// See
    /// [GtkContainer’s geometry management section][container-geometry-management]
    /// to learn more about how height-for-width allocations are performed
    /// by container widgets.
    ///
    /// If a widget does move content around to intelligently use up the
    /// allocated size then it must support the request in both
    /// `GtkSizeRequestModes` 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 `GtkWidgetClass.get_preferred_height()` 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, for `GtkWidgetClass.get_preferred_height()`
    /// it will do:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// foo_widget_get_preferred_height (GtkWidget *widget,
    ///                                  gint *min_height,
    ///                                  gint *nat_height)
    /// {
    ///    if (i_am_in_height_for_width_mode)
    ///      {
    ///        gint min_width, nat_width;
    ///
    ///        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
    ///                                                            &min_width,
    ///                                                            &nat_width);
    ///        GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
    ///                                                           (widget,
    ///                                                            min_width,
    ///                                                            min_height,
    ///                                                            nat_height);
    ///      }
    ///    else
    ///      {
    ///         ... some widgets do both. For instance, if a GtkLabel is
    ///         rotated to 90 degrees it will return the minimum and
    ///         natural height for the rotated label here.
    ///      }
    /// }
    /// ```
    ///
    /// And in `GtkWidgetClass.get_preferred_width_for_height()` it will simply return
    /// the minimum and natural width:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// foo_widget_get_preferred_width_for_height (GtkWidget *widget,
    ///                                            gint for_height,
    ///                                            gint *min_width,
    ///                                            gint *nat_width)
    /// {
    ///    if (i_am_in_height_for_width_mode)
    ///      {
    ///        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
    ///                                                            min_width,
    ///                                                            nat_width);
    ///      }
    ///    else
    ///      {
    ///         ... again if a widget is sometimes operating in
    ///         width-for-height mode (like a rotated GtkLabel) it can go
    ///         ahead and do its real width for height calculation here.
    ///      }
    /// }
    /// ```
    ///
    /// 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 this:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget,
    ///                                                    &min,
    ///                                                    &natural);
    /// ```
    ///
    /// It will not work to use the wrapper functions, such as
    /// [`WidgetExt::preferred_width()`][crate::prelude::WidgetExt::preferred_width()] inside your own size request
    /// implementation. These return a request adjusted by [`SizeGroup`][crate::SizeGroup]
    /// and by the `GtkWidgetClass.adjust_size_request()` virtual method. 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 of a
    /// container, you must use the wrapper APIs.
    /// Otherwise, you would not properly consider widget margins,
    /// [`SizeGroup`][crate::SizeGroup], and so forth.
    ///
    /// Since 3.10 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 of [`Align::Baseline`][crate::Align::Baseline], and is inside a container
    /// 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 done by the `GtkWidgetClass.get_preferred_height_and_baseline_for_width()`
    /// virtual function. It allows you to report a baseline in combination with the
    /// minimum and natural height. If there is no baseline you can return -1 to indicate
    /// this. The default implementation of this virtual function calls into the
    /// `GtkWidgetClass.get_preferred_height()` and `GtkWidgetClass.get_preferred_height_for_width()`,
    /// so if baselines are not supported it doesn’t need to be implemented.
    ///
    /// 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::allocated_baseline()`][crate::prelude::WidgetExt::allocated_baseline()].
    /// If this has a value other than -1 you need to align the widget such that the baseline
    /// appears at the position.
    ///
    /// # Style Properties
    ///
    /// [`Widget`][crate::Widget] introduces “style
    /// properties” - these are basically object properties that are stored
    /// not on the object, but in the style object associated to the widget. Style
    /// properties are set in [resource files][gtk3-Resource-Files].
    /// This mechanism is used for configuring such things as the location of the
    /// scrollbar arrows through the theme, giving theme authors more control over the
    /// look of applications without the need to write a theme engine in C.
    ///
    /// Use `gtk_widget_class_install_style_property()` to install style properties for
    /// a widget class, `gtk_widget_class_find_style_property()` or
    /// `gtk_widget_class_list_style_properties()` to get information about existing
    /// style properties and [`WidgetExt::style_get_property()`][crate::prelude::WidgetExt::style_get_property()], `gtk_widget_style_get()` or
    /// `gtk_widget_style_get_valist()` to obtain the value of a style property.
    ///
    /// # GtkWidget as GtkBuildable
    ///
    /// The GtkWidget implementation of the GtkBuildable interface supports a
    /// custom ``<accelerator>`` element, which has attributes named ”key”, ”modifiers”
    /// and ”signal” and allows to specify accelerators.
    ///
    /// An example of a UI definition fragment specifying an accelerator:
    ///
    ///
    ///
    /// **⚠️ The following code is in xml ⚠️**
    ///
    /// ```xml
    /// <object class="GtkButton">
    ///   <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>
    /// </object>
    /// ```
    ///
    /// In addition to accelerators, GtkWidget also support a custom ``<accessible>``
    /// element, which supports actions and relations. Properties on the accessible
    /// implementation of an object can be set by accessing the internal child
    /// “accessible” of a [`Widget`][crate::Widget].
    ///
    /// An example of a UI definition fragment specifying an accessible:
    ///
    ///
    ///
    /// **⚠️ The following code is in xml ⚠️**
    ///
    /// ```xml
    /// <object class="GtkLabel" id="label1"/>
    ///   <property name="label">I am a Label for a Button</property>
    /// </object>
    /// <object class="GtkButton" id="button1">
    ///   <accessibility>
    ///     <action action_name="click" translatable="yes">Click the button.</action>
    ///     <relation target="label1" type="labelled-by"/>
    ///   </accessibility>
    ///   <child internal-child="accessible">
    ///     <object class="AtkObject" id="a11y-button1">
    ///       <property name="accessible-name">Clickable Button</property>
    ///     </object>
    ///   </child>
    /// </object>
    /// ```
    ///
    /// Finally, GtkWidget allows style information such as style classes to
    /// be associated with widgets, using the custom ``<style>`` element:
    ///
    ///
    ///
    /// **⚠️ The following code is in xml ⚠️**
    ///
    /// ```xml
    /// <object class="GtkButton" id="button1">
    ///   <style>
    ///     <class name="my-special-button-class"/>
    ///     <class name="dark-button"/>
    ///   </style>
    /// </object>
    /// ```
    ///
    /// # Building composite widgets from template XML ## {`composite`-templates}
    ///
    /// GtkWidget exposes some facilities to automate the procedure
    /// of creating composite widgets using [`Builder`][crate::Builder] interface description
    /// language.
    ///
    /// To create composite widgets with [`Builder`][crate::Builder] XML, one must associate
    /// the interface description with the widget class at class initialization
    /// time using `gtk_widget_class_set_template()`.
    ///
    /// The interface description semantics expected in composite template descriptions
    /// is slightly different from regular [`Builder`][crate::Builder] XML.
    ///
    /// Unlike regular interface descriptions, `gtk_widget_class_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 the GtkBuilder but required for Glade 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 "widget" itself. You may set properties
    /// on `widget` by inserting ``<property>`` tags into the ``<template>`` tag, and also
    /// add ``<child>`` tags to add children and extend "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.
    ///
    /// An example of a GtkBuilder Template Definition:
    ///
    ///
    ///
    /// **⚠️ The following code is in xml ⚠️**
    ///
    /// ```xml
    /// <interface>
    ///   <template class="FooWidget" parent="GtkBox">
    ///     <property name="orientation">GTK_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 `gtk_widget_class_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 [`WidgetExt::init_template()`][crate::prelude::WidgetExt::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));
    /// }
    /// ```
    ///
    /// You can access widgets defined in the template using the
    /// [`WidgetExt::template_child()`][crate::prelude::WidgetExt::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
    /// `gtk_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_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_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)
    /// {
    ///
    /// }
    /// ```
    ///
    /// You can also use `gtk_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
    ///
    ///
    /// #### `app-paintable`
    ///  Readable | Writeable
    ///
    ///
    /// #### `can-default`
    ///  Readable | Writeable
    ///
    ///
    /// #### `can-focus`
    ///  Readable | Writeable
    ///
    ///
    /// #### `composite-child`
    ///  Readable
    ///
    ///
    /// #### `double-buffered`
    ///  Whether the widget is double buffered.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `events`
    ///  Readable | Writeable
    ///
    ///
    /// #### `expand`
    ///  Whether to expand in both directions. Setting this sets both [`hexpand`][struct@crate::Widget#hexpand] and [`vexpand`][struct@crate::Widget#vexpand]
    ///
    /// 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.
    ///
    /// Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
    /// GtkComboBox) implemented this property individually.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space, see [`Align`][crate::Align]
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-default`
    ///  Readable | Writeable
    ///
    ///
    /// #### `has-focus`
    ///  Readable | Writeable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of [`query-tooltip`][struct@crate::Widget#query-tooltip] on `widget`.
    /// A value of [`true`] 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.
    ///
    /// Note that setting this property to [`true`] for the first time will change
    /// the event masks of the GdkWindows of this widget to include leave-notify
    /// and motion-notify events. This cannot and will not be undone when the
    /// property is set to [`false`] again.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Readable | Writeable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally. See [`WidgetExt::set_hexpand()`][crate::prelude::WidgetExt::set_hexpand()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the [`hexpand`][struct@crate::Widget#hexpand] property. See [`WidgetExt::is_hexpand_set()`][crate::prelude::WidgetExt::is_hexpand_set()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-focus`
    ///  Readable | Writeable
    ///
    ///
    /// #### `margin`
    ///  Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    ///
    /// 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-left`
    ///  Margin on left 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-right`
    ///  Margin on right 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-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`
    ///  Readable | Writeable
    ///
    ///
    /// #### `no-show-all`
    ///  Readable | Writeable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget. See [`WidgetExt::set_opacity()`][crate::prelude::WidgetExt::set_opacity()] for
    /// more details about window opacity.
    ///
    /// Before 3.8 this was only available in GtkWindow
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `parent`
    ///  Readable | Writeable
    ///
    ///
    /// #### `receives-default`
    ///  Readable | Writeable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget. See [`WidgetExt::scale_factor()`][crate::prelude::WidgetExt::scale_factor()] for
    /// more details about widget scaling.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Readable | Writeable
    ///
    ///
    /// #### `style`
    ///  The style of the widget, which contains information about how it will look (colors, etc).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with the [Pango text markup language][PangoMarkupFormat].
    /// 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 [`None`]: [`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 [`None`]: [`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, see [`Align`][crate::Align]
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically. See [`WidgetExt::set_vexpand()`][crate::prelude::WidgetExt::set_vexpand()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the [`vexpand`][struct@crate::Widget#vexpand] property. See [`WidgetExt::is_vexpand_set()`][crate::prelude::WidgetExt::is_vexpand_set()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible`
    ///  Readable | Writeable
    ///
    ///
    /// #### `width-request`
    ///  Readable | Writeable
    ///
    ///
    /// #### `window`
    ///  The widget's window if it is realized, [`None`] otherwise.
    ///
    /// Readable
    ///
    /// ## Signals
    ///
    ///
    /// #### `accel-closures-changed`
    ///
    ///
    ///
    /// #### `button-press-event`
    ///  The ::button-press-event signal will be emitted when a button
    /// (typically from a mouse) is pressed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the
    /// widget needs to enable the [`gdk::EventMask::BUTTON_PRESS_MASK`][crate::gdk::EventMask::BUTTON_PRESS_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `button-release-event`
    ///  The ::button-release-event signal will be emitted when a button
    /// (typically from a mouse) is released.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the
    /// widget needs to enable the [`gdk::EventMask::BUTTON_RELEASE_MASK`][crate::gdk::EventMask::BUTTON_RELEASE_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `can-activate-accel`
    ///  Determines whether an accelerator that activates the signal
    /// identified by `signal_id` can currently be activated.
    /// This signal is present to allow applications and derived
    /// widgets to override the default [`Widget`][crate::Widget] handling
    /// for determining whether an accelerator can be activated.
    ///
    ///
    ///
    ///
    /// #### `child-notify`
    ///  The ::child-notify signal is emitted for each
    /// [child property][child-properties] that has
    /// changed on an object. The signal's detail holds the property name.
    ///
    /// Detailed
    ///
    ///
    /// #### `composited-changed`
    ///  The ::composited-changed signal is emitted when the composited
    /// status of `widgets` screen changes.
    /// See [`Screen::is_composited()`][crate::gdk::Screen::is_composited()].
    ///
    /// Action
    ///
    ///
    /// #### `configure-event`
    ///  The ::configure-event signal will be emitted when the size, position or
    /// stacking of the `widget`'s window has changed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `damage-event`
    ///  Emitted when a redirected window belonging to `widget` gets drawn into.
    /// The region/area members of the event shows what area of the redirected
    /// drawable was drawn into.
    ///
    ///
    ///
    ///
    /// #### `delete-event`
    ///  The ::delete-event signal is emitted if a user requests that
    /// a toplevel window is closed. The default handler for this signal
    /// destroys the window. Connecting [`WidgetExtManual::hide_on_delete()`][crate::prelude::WidgetExtManual::hide_on_delete()] to
    /// this signal will cause the window to be hidden instead, so that
    /// it can later be shown again without reconstructing it.
    ///
    ///
    ///
    ///
    /// #### `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.
    ///
    ///
    ///
    ///
    /// #### `destroy-event`
    ///  The ::destroy-event signal is emitted when a [`gdk::Window`][crate::gdk::Window] is destroyed.
    /// You rarely get this signal, because most widgets disconnect themselves
    /// from their window before they destroy it, so no widget owns the
    /// window at destroy time.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `direction-changed`
    ///  The ::direction-changed signal is emitted when the text direction
    /// of a widget changes.
    ///
    ///
    ///
    ///
    /// #### `drag-begin`
    ///  The ::drag-begin signal is emitted on the drag source when a drag is
    /// started. A typical reason to connect to this signal is to set up a
    /// custom drag icon with e.g. [`WidgetExt::drag_source_set_icon_pixbuf()`][crate::prelude::WidgetExt::drag_source_set_icon_pixbuf()].
    ///
    /// Note that some widgets set up a drag icon in the default handler of
    /// this signal, so you may have to use `g_signal_connect_after()` to
    /// override what the default handler did.
    ///
    ///
    ///
    ///
    /// #### `drag-data-delete`
    ///  The ::drag-data-delete signal is emitted on the drag source when a drag
    /// with the action [`gdk::DragAction::MOVE`][crate::gdk::DragAction::MOVE] is successfully completed. The signal
    /// handler is responsible for deleting the data that has been dropped. What
    /// "delete" means depends on the context of the drag operation.
    ///
    ///
    ///
    ///
    /// #### `drag-data-get`
    ///  The ::drag-data-get signal is emitted on the drag source when the drop
    /// site requests the data which is dragged. It is the responsibility of
    /// the signal handler to fill `data` with the data in the format which
    /// is indicated by `info`. See [`SelectionData::set()`][crate::SelectionData::set()] and
    /// [`SelectionData::set_text()`][crate::SelectionData::set_text()].
    ///
    ///
    ///
    ///
    /// #### `drag-data-received`
    ///  The ::drag-data-received signal is emitted on the drop site when the
    /// dragged data has been received. If the data was received in order to
    /// determine whether the drop will be accepted, the handler is expected
    /// to call `gdk_drag_status()` and not finish the drag.
    /// If the data was received in response to a [`drag-drop`][struct@crate::Widget#drag-drop] signal
    /// (and this is the last target to be received), the handler for this
    /// signal is expected to process the received data and then call
    /// `gtk_drag_finish()`, setting the `success` parameter depending on
    /// whether the data was processed successfully.
    ///
    /// Applications must create some means to determine why the signal was emitted
    /// and therefore whether to call `gdk_drag_status()` or `gtk_drag_finish()`.
    ///
    /// The handler may inspect the selected action with
    /// [`DragContext::selected_action()`][crate::gdk::DragContext::selected_action()] before calling
    /// `gtk_drag_finish()`, e.g. to implement [`gdk::DragAction::ASK`][crate::gdk::DragAction::ASK] as
    /// shown in the following example:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// void
    /// drag_data_received (GtkWidget          *widget,
    ///                     GdkDragContext     *context,
    ///                     gint                x,
    ///                     gint                y,
    ///                     GtkSelectionData   *data,
    ///                     guint               info,
    ///                     guint               time)
    /// {
    ///   if ((data->length >= 0) && (data->format == 8))
    ///     {
    ///       GdkDragAction action;
    ///
    ///       // handle data here
    ///
    ///       action = gdk_drag_context_get_selected_action (context);
    ///       if (action == GDK_ACTION_ASK)
    ///         {
    ///           GtkWidget *dialog;
    ///           gint response;
    ///
    ///           dialog = gtk_message_dialog_new (NULL,
    ///                                            GTK_DIALOG_MODAL |
    ///                                            GTK_DIALOG_DESTROY_WITH_PARENT,
    ///                                            GTK_MESSAGE_INFO,
    ///                                            GTK_BUTTONS_YES_NO,
    ///                                            "Move the data ?\n");
    ///           response = gtk_dialog_run (GTK_DIALOG (dialog));
    ///           gtk_widget_destroy (dialog);
    ///
    ///           if (response == GTK_RESPONSE_YES)
    ///             action = GDK_ACTION_MOVE;
    ///           else
    ///             action = GDK_ACTION_COPY;
    ///          }
    ///
    ///       gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time);
    ///     }
    ///   else
    ///     gtk_drag_finish (context, FALSE, FALSE, time);
    ///  }
    /// ```
    ///
    ///
    ///
    ///
    /// #### `drag-drop`
    ///  The ::drag-drop signal is emitted on the drop site when the user drops
    /// the data onto the widget. The signal handler must determine whether
    /// the cursor position is in a drop zone or not. If it is not in a drop
    /// zone, it returns [`false`] and no further processing is necessary.
    /// Otherwise, the handler returns [`true`]. In this case, the handler must
    /// ensure that `gtk_drag_finish()` is called to let the source know that
    /// the drop is done. The call to `gtk_drag_finish()` can be done either
    /// directly or in a [`drag-data-received`][struct@crate::Widget#drag-data-received] handler which gets
    /// triggered by calling [`WidgetExt::drag_get_data()`][crate::prelude::WidgetExt::drag_get_data()] to receive the data for one
    /// or more of the supported targets.
    ///
    ///
    ///
    ///
    /// #### `drag-end`
    ///  The ::drag-end signal is emitted on the drag source when a drag is
    /// finished. A typical reason to connect to this signal is to undo
    /// things done in [`drag-begin`][struct@crate::Widget#drag-begin].
    ///
    ///
    ///
    ///
    /// #### `drag-failed`
    ///  The ::drag-failed signal is emitted on the drag source when a drag has
    /// failed. The signal handler may hook custom code to handle a failed DnD
    /// operation based on the type of error, it returns [`true`] is the failure has
    /// been already handled (not showing the default "drag operation failed"
    /// animation), otherwise it returns [`false`].
    ///
    ///
    ///
    ///
    /// #### `drag-leave`
    ///  The ::drag-leave signal is emitted on the drop site when the cursor
    /// leaves the widget. A typical reason to connect to this signal is to
    /// undo things done in [`drag-motion`][struct@crate::Widget#drag-motion], e.g. undo highlighting
    /// with [`WidgetExt::drag_unhighlight()`][crate::prelude::WidgetExt::drag_unhighlight()].
    ///
    ///
    /// Likewise, the [`drag-leave`][struct@crate::Widget#drag-leave] signal is also emitted before the
    /// ::drag-drop signal, for instance to allow cleaning up of a preview item
    /// created in the [`drag-motion`][struct@crate::Widget#drag-motion] signal handler.
    ///
    ///
    ///
    ///
    /// #### `drag-motion`
    ///  The ::drag-motion signal is emitted on the drop site when the user
    /// moves the cursor over the widget during a drag. The signal handler
    /// must determine whether the cursor position is in a drop zone or not.
    /// If it is not in a drop zone, it returns [`false`] and no further processing
    /// is necessary. Otherwise, the handler returns [`true`]. In this case, the
    /// handler is responsible for providing the necessary information for
    /// displaying feedback to the user, by calling `gdk_drag_status()`.
    ///
    /// If the decision whether the drop will be accepted or rejected can't be
    /// made based solely on the cursor position and the type of the data, the
    /// handler may inspect the dragged data by calling [`WidgetExt::drag_get_data()`][crate::prelude::WidgetExt::drag_get_data()] and
    /// defer the `gdk_drag_status()` call to the [`drag-data-received`][struct@crate::Widget#drag-data-received]
    /// handler. Note that you must pass [`DestDefaults::DROP`][crate::DestDefaults::DROP],
    /// [`DestDefaults::MOTION`][crate::DestDefaults::MOTION] or [`DestDefaults::ALL`][crate::DestDefaults::ALL] to [`WidgetExtManual::drag_dest_set()`][crate::prelude::WidgetExtManual::drag_dest_set()]
    /// when using the drag-motion signal that way.
    ///
    /// Also note that there is no drag-enter signal. The drag receiver has to
    /// keep track of whether he has received any drag-motion signals since the
    /// last [`drag-leave`][struct@crate::Widget#drag-leave] and if not, treat the drag-motion signal as
    /// an "enter" signal. Upon an "enter", the handler will typically highlight
    /// the drop site with [`WidgetExt::drag_highlight()`][crate::prelude::WidgetExt::drag_highlight()].
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// drag_motion (GtkWidget      *widget,
    ///              GdkDragContext *context,
    ///              gint            x,
    ///              gint            y,
    ///              guint           time)
    /// {
    ///   GdkAtom target;
    ///
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (!private_data->drag_highlight)
    ///    {
    ///      private_data->drag_highlight = 1;
    ///      gtk_drag_highlight (widget);
    ///    }
    ///
    ///   target = gtk_drag_dest_find_target (widget, context, NULL);
    ///   if (target == GDK_NONE)
    ///     gdk_drag_status (context, 0, time);
    ///   else
    ///    {
    ///      private_data->pending_status
    ///         = gdk_drag_context_get_suggested_action (context);
    ///      gtk_drag_get_data (widget, context, target, time);
    ///    }
    ///
    ///   return TRUE;
    /// }
    ///
    /// static void
    /// drag_data_received (GtkWidget        *widget,
    ///                     GdkDragContext   *context,
    ///                     gint              x,
    ///                     gint              y,
    ///                     GtkSelectionData *selection_data,
    ///                     guint             info,
    ///                     guint             time)
    /// {
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (private_data->suggested_action)
    ///    {
    ///      private_data->suggested_action = 0;
    ///
    ///      // We are getting this data due to a request in drag_motion,
    ///      // rather than due to a request in drag_drop, so we are just
    ///      // supposed to call gdk_drag_status(), not actually paste in
    ///      // the data.
    ///
    ///      str = gtk_selection_data_get_text (selection_data);
    ///      if (!data_is_acceptable (str))
    ///        gdk_drag_status (context, 0, time);
    ///      else
    ///        gdk_drag_status (context,
    ///                         private_data->suggested_action,
    ///                         time);
    ///    }
    ///   else
    ///    {
    ///      // accept the drop
    ///    }
    /// }
    /// ```
    ///
    ///
    ///
    ///
    /// #### `draw`
    ///  This signal is emitted when a widget is supposed to render itself.
    /// The `widget`'s top left corner must be painted at the origin of
    /// the passed in context and be sized to the values returned by
    /// [`WidgetExt::allocated_width()`][crate::prelude::WidgetExt::allocated_width()] and
    /// [`WidgetExt::allocated_height()`][crate::prelude::WidgetExt::allocated_height()].
    ///
    /// Signal handlers connected to this signal can modify the cairo
    /// context passed as `cr` in any way they like and don't need to
    /// restore it. The signal emission takes care of calling `cairo_save()`
    /// before and `cairo_restore()` after invoking the handler.
    ///
    /// The signal handler will get a `cr` with a clip region already set to the
    /// widget's dirty region, i.e. to the area that needs repainting. Complicated
    /// widgets that want to avoid redrawing themselves completely can get the full
    /// extents of the clip region with `gdk_cairo_get_clip_rectangle()`, or they can
    /// get a finer-grained representation of the dirty region with
    /// `cairo_copy_clip_rectangle_list()`.
    ///
    ///
    ///
    ///
    /// #### `enter-notify-event`
    ///  The ::enter-notify-event will be emitted when the pointer enters
    /// the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::ENTER_NOTIFY_MASK`][crate::gdk::EventMask::ENTER_NOTIFY_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `event`
    ///  The GTK+ main loop will emit three signals for each GDK event delivered
    /// to a widget: one generic ::event signal, another, more specific,
    /// signal that matches the type of event delivered (e.g.
    /// [`key-press-event`][struct@crate::Widget#key-press-event]) and finally a generic
    /// [`event-after`][struct@crate::Widget#event-after] signal.
    ///
    ///
    ///
    ///
    /// #### `event-after`
    ///  After the emission of the [`event`][struct@crate::Widget#event] signal and (optionally)
    /// the second more specific signal, ::event-after will be emitted
    /// regardless of the previous two signals handlers return values.
    ///
    ///
    ///
    ///
    /// #### `focus`
    ///
    ///
    ///
    /// #### `focus-in-event`
    ///  The ::focus-in-event signal will be emitted when the keyboard focus
    /// enters the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::FOCUS_CHANGE_MASK`][crate::gdk::EventMask::FOCUS_CHANGE_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `focus-out-event`
    ///  The ::focus-out-event signal will be emitted when the keyboard focus
    /// leaves the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::FOCUS_CHANGE_MASK`][crate::gdk::EventMask::FOCUS_CHANGE_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `grab-broken-event`
    ///  Emitted when a pointer or keyboard grab on a window belonging
    /// to `widget` gets broken.
    ///
    /// On X11, this happens when the grab window becomes unviewable
    /// (i.e. it or one of its ancestors is unmapped), or if the same
    /// application grabs the pointer or keyboard again.
    ///
    ///
    ///
    ///
    /// #### `grab-focus`
    ///  Action
    ///
    ///
    /// #### `grab-notify`
    ///  The ::grab-notify signal is emitted when a widget becomes
    /// shadowed by a GTK+ grab (not a pointer or keyboard grab) on
    /// another widget, or when it becomes unshadowed due to a grab
    /// being removed.
    ///
    /// A widget is shadowed by a [`WidgetExt::grab_add()`][crate::prelude::WidgetExt::grab_add()] when the topmost
    /// grab widget in the grab stack of its window group is not
    /// its ancestor.
    ///
    ///
    ///
    ///
    /// #### `hide`
    ///  The ::hide signal is emitted when `widget` is hidden, for example with
    /// [`WidgetExt::hide()`][crate::prelude::WidgetExt::hide()].
    ///
    ///
    ///
    ///
    /// #### `hierarchy-changed`
    ///  The ::hierarchy-changed signal is emitted when the
    /// anchored state of a widget changes. A widget is
    /// “anchored” when its toplevel
    /// ancestor is a [`Window`][crate::Window]. This signal is emitted when
    /// a widget changes from un-anchored to anchored or vice-versa.
    ///
    ///
    ///
    ///
    /// #### `key-press-event`
    ///  The ::key-press-event signal is emitted when a key is pressed. The signal
    /// emission will reoccur at the key-repeat rate when the key is kept pressed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::KEY_PRESS_MASK`][crate::gdk::EventMask::KEY_PRESS_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `key-release-event`
    ///  The ::key-release-event signal is emitted when a key is released.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::KEY_RELEASE_MASK`][crate::gdk::EventMask::KEY_RELEASE_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `keynav-failed`
    ///  Gets emitted if keyboard navigation fails.
    /// See [`WidgetExt::keynav_failed()`][crate::prelude::WidgetExt::keynav_failed()] for details.
    ///
    ///
    ///
    ///
    /// #### `leave-notify-event`
    ///  The ::leave-notify-event will be emitted when the pointer leaves
    /// the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::LEAVE_NOTIFY_MASK`][crate::gdk::EventMask::LEAVE_NOTIFY_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `map`
    ///  The ::map signal is emitted when `widget` is going to be mapped, that is
    /// when the widget is visible (which is controlled with
    /// [`WidgetExt::set_visible()`][crate::prelude::WidgetExt::set_visible()]) and all its parents up to the toplevel widget
    /// are also visible. Once the map has occurred, [`map-event`][struct@crate::Widget#map-event] will
    /// be emitted.
    ///
    /// 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].
    ///
    ///
    ///
    ///
    /// #### `map-event`
    ///  The ::map-event signal will be emitted when the `widget`'s window is
    /// mapped. A window is mapped when it becomes visible on the screen.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `mnemonic-activate`
    ///  The default handler for this signal activates `widget` if `group_cycling`
    /// is [`false`], or just makes `widget` grab focus if `group_cycling` is [`true`].
    ///
    ///
    ///
    ///
    /// #### `motion-notify-event`
    ///  The ::motion-notify-event signal is emitted when the pointer moves
    /// over the widget's [`gdk::Window`][crate::gdk::Window].
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget
    /// needs to enable the [`gdk::EventMask::POINTER_MOTION_MASK`][crate::gdk::EventMask::POINTER_MOTION_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `move-focus`
    ///  Action
    ///
    ///
    /// #### `parent-set`
    ///  The ::parent-set signal is emitted when a new parent
    /// has been set on a widget.
    ///
    ///
    ///
    ///
    /// #### `popup-menu`
    ///  This signal gets emitted whenever a widget should pop up a context
    /// menu. This usually happens through the standard key binding mechanism;
    /// by pressing a certain key while a widget is focused, the user can cause
    /// the widget to pop up a menu. For example, the [`Entry`][crate::Entry] widget creates
    /// a menu with clipboard commands. See the
    /// [Popup Menu Migration Checklist][checklist-popup-menu]
    /// for an example of how to use this signal.
    ///
    /// Action
    ///
    ///
    /// #### `property-notify-event`
    ///  The ::property-notify-event signal will be emitted when a property on
    /// the `widget`'s window has been changed or deleted.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROPERTY_CHANGE_MASK`][crate::gdk::EventMask::PROPERTY_CHANGE_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `proximity-in-event`
    ///  To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROXIMITY_IN_MASK`][crate::gdk::EventMask::PROXIMITY_IN_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `proximity-out-event`
    ///  To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROXIMITY_OUT_MASK`][crate::gdk::EventMask::PROXIMITY_OUT_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `query-tooltip`
    ///  Emitted when [`has-tooltip`][struct@crate::Widget#has-tooltip] 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`
    ///  The ::realize signal is emitted when `widget` is associated with a
    /// [`gdk::Window`][crate::gdk::Window], which 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).
    ///
    ///
    ///
    ///
    /// #### `screen-changed`
    ///  The ::screen-changed signal gets emitted when the
    /// screen of a widget has changed.
    ///
    ///
    ///
    ///
    /// #### `scroll-event`
    ///  The ::scroll-event signal is emitted when a button in the 4 to 7
    /// range is pressed. Wheel mice are usually configured to generate
    /// button press events for buttons 4 and 5 when the wheel is turned.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::SCROLL_MASK`][crate::gdk::EventMask::SCROLL_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `selection-clear-event`
    ///  The ::selection-clear-event signal will be emitted when the
    /// the `widget`'s window has lost ownership of a selection.
    ///
    ///
    ///
    ///
    /// #### `selection-get`
    ///
    ///
    ///
    /// #### `selection-notify-event`
    ///
    ///
    ///
    /// #### `selection-received`
    ///
    ///
    ///
    /// #### `selection-request-event`
    ///  The ::selection-request-event signal will be emitted when
    /// another client requests ownership of the selection owned by
    /// the `widget`'s window.
    ///
    ///
    ///
    ///
    /// #### `show`
    ///  The ::show signal is emitted when `widget` is shown, for example with
    /// [`WidgetExt::show()`][crate::prelude::WidgetExt::show()].
    ///
    ///
    ///
    ///
    /// #### `show-help`
    ///  Action
    ///
    ///
    /// #### `size-allocate`
    ///
    ///
    ///
    /// #### `state-changed`
    ///  The ::state-changed signal is emitted when the widget state changes.
    /// See `gtk_widget_get_state()`.
    ///
    ///
    ///
    ///
    /// #### `state-flags-changed`
    ///  The ::state-flags-changed signal is emitted when the widget state
    /// changes, see [`WidgetExt::state_flags()`][crate::prelude::WidgetExt::state_flags()].
    ///
    ///
    ///
    ///
    /// #### `style-set`
    ///  The ::style-set signal is emitted when a new style has been set
    /// on a widget. Note that style-modifying functions like
    /// `gtk_widget_modify_base()` also cause this signal to be emitted.
    ///
    /// Note that this signal is emitted for changes to the deprecated
    /// `GtkStyle`. To track changes to the [`StyleContext`][crate::StyleContext] associated
    /// with a widget, use the [`style-updated`][struct@crate::Widget#style-updated] signal.
    ///
    ///
    ///
    ///
    /// #### `style-updated`
    ///  The ::style-updated signal is a convenience signal that is emitted when the
    /// [`changed`][struct@crate::StyleContext#changed] signal is emitted on the `widget`'s associated
    /// [`StyleContext`][crate::StyleContext] as returned by [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()].
    ///
    /// Note that style-modifying functions like `gtk_widget_override_color()` also
    /// cause this signal to be emitted.
    ///
    ///
    ///
    ///
    /// #### `touch-event`
    ///
    ///
    ///
    /// #### `unmap`
    ///  The ::unmap signal is emitted when `widget` is going to be unmapped, which
    /// means that 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.
    ///
    ///
    ///
    ///
    /// #### `unmap-event`
    ///  The ::unmap-event signal will be emitted when the `widget`'s window is
    /// unmapped. A window is unmapped when it becomes invisible on the screen.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `unrealize`
    ///  The ::unrealize signal is emitted when the [`gdk::Window`][crate::gdk::Window] associated with
    /// `widget` is destroyed, which 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).
    ///
    ///
    ///
    ///
    /// #### `visibility-notify-event`
    ///  The ::visibility-notify-event will be emitted when the `widget`'s
    /// window is obscured or unobscured.
    ///
    /// To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::VISIBILITY_NOTIFY_MASK`][crate::gdk::EventMask::VISIBILITY_NOTIFY_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `window-state-event`
    ///  The ::window-state-event will be emitted when the state of the
    /// toplevel window associated to the `widget` changes.
    ///
    /// To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget
    /// needs to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable
    /// this mask automatically for all new windows.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`BuildableExtManual`][trait@crate::prelude::BuildableExtManual]
    #[doc(alias = "GtkWidget")]
    pub struct Widget(Object<ffi::GtkWidget, ffi::GtkWidgetClass>) @implements Buildable;

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

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

    //#[doc(alias = "gtk_widget_new")]
    //pub fn new(type_: glib::types::Type, first_property_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Widget {
    //    unsafe { TODO: call ffi:gtk_widget_new() }
    //}

    /// Obtains the current 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 where the
    /// direction has not been explicitly set by [`WidgetExt::set_direction()`][crate::prelude::WidgetExt::set_direction()].
    /// ## `dir`
    /// the new default direction. This cannot be
    ///  [`TextDirection::None`][crate::TextDirection::None].
    #[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 fmt::Display for Widget {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&WidgetExt::widget_name(self))
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Widget>> Sealed for T {}
}

/// Trait containing all [`struct@Widget`] methods.
///
/// # Implementors
///
/// [`Actionable`][struct@crate::Actionable], [`AppChooser`][struct@crate::AppChooser], [`Calendar`][struct@crate::Calendar], [`CellEditable`][struct@crate::CellEditable], [`CellView`][struct@crate::CellView], [`Container`][struct@crate::Container], [`DrawingArea`][struct@crate::DrawingArea], [`Entry`][struct@crate::Entry], [`GLArea`][struct@crate::GLArea], [`Invisible`][struct@crate::Invisible], [`LevelBar`][struct@crate::LevelBar], [`Misc`][struct@crate::Misc], [`ProgressBar`][struct@crate::ProgressBar], [`Range`][struct@crate::Range], [`Separator`][struct@crate::Separator], [`Spinner`][struct@crate::Spinner], [`Switch`][struct@crate::Switch], [`ToolShell`][struct@crate::ToolShell], [`Widget`][struct@crate::Widget]
pub trait WidgetExt: IsA<Widget> + sealed::Sealed + 'static {
    /// For widgets that can be “activated” (buttons, menu items, etc.)
    /// this function activates them. Activation is what happens when you
    /// press Enter on a widget during key navigation. If `self` isn't
    /// activatable, the function returns [`false`].
    ///
    /// # Returns
    ///
    /// [`true`] if the widget was activatable
    #[doc(alias = "gtk_widget_activate")]
    fn activate(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_activate(self.as_ref().to_glib_none().0)) }
    }

    /// Installs an accelerator for this `self` in `accel_group` that causes
    /// `accel_signal` to be emitted if the accelerator is activated.
    /// The `accel_group` needs to be added to the widget’s toplevel via
    /// [`GtkWindowExt::add_accel_group()`][crate::prelude::GtkWindowExt::add_accel_group()], and the signal must be of type `G_SIGNAL_ACTION`.
    /// Accelerators added through this function are not user changeable during
    /// runtime. If you want to support accelerators that can be changed by the
    /// user, use `gtk_accel_map_add_entry()` and [`set_accel_path()`][Self::set_accel_path()] or
    /// [`GtkMenuItemExt::set_accel_path()`][crate::prelude::GtkMenuItemExt::set_accel_path()] instead.
    /// ## `accel_signal`
    /// widget signal to emit on accelerator activation
    /// ## `accel_group`
    /// accel group for this widget, added to its toplevel
    /// ## `accel_key`
    /// GDK keyval of the accelerator
    /// ## `accel_mods`
    /// modifier key combination of the accelerator
    /// ## `accel_flags`
    /// flag accelerators, e.g. [`AccelFlags::VISIBLE`][crate::AccelFlags::VISIBLE]
    #[doc(alias = "gtk_widget_add_accelerator")]
    fn add_accelerator(
        &self,
        accel_signal: &str,
        accel_group: &impl IsA<AccelGroup>,
        accel_key: u32,
        accel_mods: gdk::ModifierType,
        accel_flags: AccelFlags,
    ) {
        unsafe {
            ffi::gtk_widget_add_accelerator(
                self.as_ref().to_glib_none().0,
                accel_signal.to_glib_none().0,
                accel_group.as_ref().to_glib_none().0,
                accel_key,
                accel_mods.into_glib(),
                accel_flags.into_glib(),
            );
        }
    }

    /// Adds the device events in the bitfield `events` to the event mask for
    /// `self`. See [`set_device_events()`][Self::set_device_events()] for details.
    /// ## `device`
    /// a [`gdk::Device`][crate::gdk::Device]
    /// ## `events`
    /// an event mask, see [`gdk::EventMask`][crate::gdk::EventMask]
    #[doc(alias = "gtk_widget_add_device_events")]
    fn add_device_events(&self, device: &gdk::Device, events: gdk::EventMask) {
        unsafe {
            ffi::gtk_widget_add_device_events(
                self.as_ref().to_glib_none().0,
                device.to_glib_none().0,
                events.into_glib(),
            );
        }
    }

    /// Adds a widget to the list of mnemonic labels for
    /// this widget. (See [`list_mnemonic_labels()`][Self::list_mnemonic_labels()]). Note 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, by using a connection
    /// to the [`destroy`][struct@crate::Widget#destroy] signal or a weak notifier.
    /// ## `label`
    /// a [`Widget`][crate::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,
            );
        }
    }

    /// Determines whether an accelerator that activates the signal
    /// identified by `signal_id` can currently be activated.
    /// This is done by emitting the [`can-activate-accel`][struct@crate::Widget#can-activate-accel]
    /// signal on `self`; if the signal isn’t overridden by a
    /// handler or in a derived widget, then the default check is
    /// that the widget must be sensitive, and the widget and all
    /// its ancestors mapped.
    /// ## `signal_id`
    /// the ID of a signal installed on `self`
    ///
    /// # Returns
    ///
    /// [`true`] if the accelerator can be activated.
    #[doc(alias = "gtk_widget_can_activate_accel")]
    fn can_activate_accel(&self, signal_id: u32) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_can_activate_accel(
                self.as_ref().to_glib_none().0,
                signal_id,
            ))
        }
    }

    /// 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, and [`ContainerExt::set_focus_chain()`][crate::prelude::ContainerExt::set_focus_chain()] to
    /// change the focus tab order. So you may want to investigate those
    /// functions instead.
    ///
    /// [`child_focus()`][Self::child_focus()] is called by containers as the user moves
    /// around the window using keyboard shortcuts. `direction` indicates
    /// what kind of motion is taking place (up, down, left, right, tab
    /// forward, tab backward). [`child_focus()`][Self::child_focus()] emits the
    /// [`focus`][struct@crate::Widget#focus] signal; widgets override the default handler
    /// for this signal in order to implement appropriate focus behavior.
    ///
    /// The default ::focus handler 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. If returning [`true`], widgets normally
    /// call [`grab_focus()`][Self::grab_focus()] to place the focus accordingly;
    /// if returning [`false`], they don’t modify the current focus location.
    /// ## `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(),
            ))
        }
    }

    /// Emits a [`child-notify`][struct@crate::Widget#child-notify] signal for the
    /// [child property][child-properties] `child_property`
    /// on `self`.
    ///
    /// This is the analogue of [`ObjectExt::notify()`][crate::glib::prelude::ObjectExt::notify()] for child properties.
    ///
    /// Also see [`ContainerExt::child_notify()`][crate::prelude::ContainerExt::child_notify()].
    /// ## `child_property`
    /// the name of a child property installed on the
    ///  class of `self`’s parent
    #[doc(alias = "gtk_widget_child_notify")]
    fn child_notify(&self, child_property: &str) {
        unsafe {
            ffi::gtk_widget_child_notify(
                self.as_ref().to_glib_none().0,
                child_property.to_glib_none().0,
            );
        }
    }

    /// Computes whether a container should give this widget extra space
    /// when possible. Containers 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(),
            ))
        }
    }

    /// Creates a new [`pango::Context`][crate::pango::Context] with the appropriate font map,
    /// font options, font description, and base direction for drawing
    /// text for this widget. 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] with the appropriate font map,
    /// font description, and base direction for drawing text for
    /// this widget.
    ///
    /// If you keep a [`pango::Layout`][crate::pango::Layout] created in this way around, you need
    /// to re-create it when the widget [`pango::Context`][crate::pango::Context] is replaced.
    /// This can be tracked by using the [`screen-changed`][struct@crate::Widget#screen-changed] signal
    /// on the widget.
    /// ## `text`
    /// text to set on the layout (can be [`None`])
    ///
    /// # 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,
            ))
        }
    }

    //#[doc(alias = "gtk_widget_destroyed")]
    //fn destroyed(&self, widget_pointer: impl IsA<Widget>) {
    //    unsafe { TODO: call ffi:gtk_widget_destroyed() }
    //}

    /// Returns [`true`] if `device` has been shadowed by a GTK+
    /// device grab on another widget, so it would stop sending
    /// events to `self`. This may be used in the
    /// [`grab-notify`][struct@crate::Widget#grab-notify] signal to check for specific
    /// devices. See [`device_grab_add()`][crate::device_grab_add()].
    /// ## `device`
    /// a [`gdk::Device`][crate::gdk::Device]
    ///
    /// # Returns
    ///
    /// [`true`] if there is an ongoing grab on `device`
    ///  by another [`Widget`][crate::Widget] than `self`.
    #[doc(alias = "gtk_widget_device_is_shadowed")]
    fn device_is_shadowed(&self, device: &gdk::Device) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_device_is_shadowed(
                self.as_ref().to_glib_none().0,
                device.to_glib_none().0,
            ))
        }
    }

    /// Initiates a drag on the source side. The function only needs to be used
    /// when the application is starting drags itself, and is not needed when
    /// [`WidgetExtManual::drag_source_set()`][crate::prelude::WidgetExtManual::drag_source_set()] is used.
    ///
    /// The `event` is used to retrieve the timestamp that will be used internally to
    /// grab the pointer. If `event` is [`None`], then `GDK_CURRENT_TIME` will be used.
    /// However, you should try to pass a real event in all cases, since that can be
    /// used to get information about the drag.
    ///
    /// Generally there are three cases when you want to start a drag by hand by
    /// calling this function:
    ///
    /// 1. During a [`button-press-event`][struct@crate::Widget#button-press-event] handler, if you want to start a drag
    /// immediately when the user presses the mouse button. Pass the `event`
    /// that you have in your [`button-press-event`][struct@crate::Widget#button-press-event] handler.
    ///
    /// 2. During a [`motion-notify-event`][struct@crate::Widget#motion-notify-event] handler, if you want to start a drag
    /// when the mouse moves past a certain threshold distance after a button-press.
    /// Pass the `event` that you have in your [`motion-notify-event`][struct@crate::Widget#motion-notify-event] handler.
    ///
    /// 3. During a timeout handler, if you want to start a drag after the mouse
    /// button is held down for some time. Try to save the last event that you got
    /// from the mouse, using `gdk_event_copy()`, and pass it to this function
    /// (remember to free the event with `gdk_event_free()` when you are done).
    /// If you really cannot pass a real event, pass [`None`] instead.
    /// ## `targets`
    /// The targets (data formats) in which the
    ///  source can provide the data
    /// ## `actions`
    /// A bitmask of the allowed drag actions for this drag
    /// ## `button`
    /// The button the user clicked to start the drag
    /// ## `event`
    /// The event that triggered the start of the drag,
    ///  or [`None`] if none can be obtained.
    /// ## `x`
    /// The initial x coordinate to start dragging from, in the coordinate space
    ///  of `self`. If -1 is passed, the coordinates are retrieved from `event` or
    ///  the current pointer position
    /// ## `y`
    /// The initial y coordinate to start dragging from, in the coordinate space
    ///  of `self`. If -1 is passed, the coordinates are retrieved from `event` or
    ///  the current pointer position
    ///
    /// # Returns
    ///
    /// the context for this drag
    #[doc(alias = "gtk_drag_begin_with_coordinates")]
    fn drag_begin_with_coordinates(
        &self,
        targets: &TargetList,
        actions: gdk::DragAction,
        button: i32,
        event: Option<&gdk::Event>,
        x: i32,
        y: i32,
    ) -> Option<gdk::DragContext> {
        unsafe {
            from_glib_none(ffi::gtk_drag_begin_with_coordinates(
                self.as_ref().to_glib_none().0,
                targets.to_glib_none().0,
                actions.into_glib(),
                button,
                mut_override(event.to_glib_none().0),
                x,
                y,
            ))
        }
    }

    /// Checks to see if a mouse drag starting at (`start_x`, `start_y`) and ending
    /// at (`current_x`, `current_y`) has passed the GTK+ drag threshold, and thus
    /// should trigger the beginning of a drag-and-drop operation.
    /// ## `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,
            ))
        }
    }

    /// Add the image targets supported by [`SelectionData`][crate::SelectionData] to
    /// the target list of the drag destination. The targets
    /// are added with `info` = 0. If you need another value,
    /// use [`TargetList::add_image_targets()`][crate::TargetList::add_image_targets()] and
    /// [`drag_dest_set_target_list()`][Self::drag_dest_set_target_list()].
    #[doc(alias = "gtk_drag_dest_add_image_targets")]
    fn drag_dest_add_image_targets(&self) {
        unsafe {
            ffi::gtk_drag_dest_add_image_targets(self.as_ref().to_glib_none().0);
        }
    }

    /// Add the text targets supported by [`SelectionData`][crate::SelectionData] to
    /// the target list of the drag destination. The targets
    /// are added with `info` = 0. If you need another value,
    /// use [`TargetList::add_text_targets()`][crate::TargetList::add_text_targets()] and
    /// [`drag_dest_set_target_list()`][Self::drag_dest_set_target_list()].
    #[doc(alias = "gtk_drag_dest_add_text_targets")]
    fn drag_dest_add_text_targets(&self) {
        unsafe {
            ffi::gtk_drag_dest_add_text_targets(self.as_ref().to_glib_none().0);
        }
    }

    /// Add the URI targets supported by [`SelectionData`][crate::SelectionData] to
    /// the target list of the drag destination. The targets
    /// are added with `info` = 0. If you need another value,
    /// use [`TargetList::add_uri_targets()`][crate::TargetList::add_uri_targets()] and
    /// [`drag_dest_set_target_list()`][Self::drag_dest_set_target_list()].
    #[doc(alias = "gtk_drag_dest_add_uri_targets")]
    fn drag_dest_add_uri_targets(&self) {
        unsafe {
            ffi::gtk_drag_dest_add_uri_targets(self.as_ref().to_glib_none().0);
        }
    }

    /// Looks for a match between the supported targets of `context` and the
    /// `dest_target_list`, returning the first matching target, otherwise
    /// returning `GDK_NONE`. `dest_target_list` should usually be the return
    /// value from [`drag_dest_get_target_list()`][Self::drag_dest_get_target_list()], but some widgets may
    /// have different valid targets for different parts of the widget; in
    /// that case, they will have to implement a drag_motion handler that
    /// passes the correct target list to this function.
    /// ## `context`
    /// drag context
    /// ## `target_list`
    /// list of droppable targets, or [`None`] to use
    ///  gtk_drag_dest_get_target_list (`self`).
    ///
    /// # Returns
    ///
    /// first target that the source offers
    ///  and the dest can accept, or `GDK_NONE`
    #[doc(alias = "gtk_drag_dest_find_target")]
    fn drag_dest_find_target(
        &self,
        context: &gdk::DragContext,
        target_list: Option<&TargetList>,
    ) -> Option<gdk::Atom> {
        unsafe {
            from_glib_none(ffi::gtk_drag_dest_find_target(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                target_list.to_glib_none().0,
            ))
        }
    }

    /// Returns the list of targets this widget can accept from
    /// drag-and-drop.
    ///
    /// # Returns
    ///
    /// the [`TargetList`][crate::TargetList], or [`None`] if none
    #[doc(alias = "gtk_drag_dest_get_target_list")]
    fn drag_dest_get_target_list(&self) -> Option<TargetList> {
        unsafe {
            from_glib_none(ffi::gtk_drag_dest_get_target_list(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the widget has been configured to always
    /// emit [`drag-motion`][struct@crate::Widget#drag-motion] signals.
    ///
    /// # Returns
    ///
    /// [`true`] if the widget always emits
    ///  [`drag-motion`][struct@crate::Widget#drag-motion] events
    #[doc(alias = "gtk_drag_dest_get_track_motion")]
    fn drag_dest_get_track_motion(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_drag_dest_get_track_motion(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the target types that this widget can accept from drag-and-drop.
    /// The widget must first be made into a drag destination with
    /// [`WidgetExtManual::drag_dest_set()`][crate::prelude::WidgetExtManual::drag_dest_set()].
    /// ## `target_list`
    /// list of droppable targets, or [`None`] for none
    #[doc(alias = "gtk_drag_dest_set_target_list")]
    fn drag_dest_set_target_list(&self, target_list: Option<&TargetList>) {
        unsafe {
            ffi::gtk_drag_dest_set_target_list(
                self.as_ref().to_glib_none().0,
                target_list.to_glib_none().0,
            );
        }
    }

    /// Tells the widget to emit [`drag-motion`][struct@crate::Widget#drag-motion] and
    /// [`drag-leave`][struct@crate::Widget#drag-leave] events regardless of the targets and the
    /// [`DestDefaults::MOTION`][crate::DestDefaults::MOTION] flag.
    ///
    /// This may be used when a widget wants to do generic
    /// actions regardless of the targets that the source offers.
    /// ## `track_motion`
    /// whether to accept all targets
    #[doc(alias = "gtk_drag_dest_set_track_motion")]
    fn drag_dest_set_track_motion(&self, track_motion: bool) {
        unsafe {
            ffi::gtk_drag_dest_set_track_motion(
                self.as_ref().to_glib_none().0,
                track_motion.into_glib(),
            );
        }
    }

    /// Clears information about a drop destination set with
    /// [`WidgetExtManual::drag_dest_set()`][crate::prelude::WidgetExtManual::drag_dest_set()]. The widget will no longer receive
    /// notification of drags.
    #[doc(alias = "gtk_drag_dest_unset")]
    fn drag_dest_unset(&self) {
        unsafe {
            ffi::gtk_drag_dest_unset(self.as_ref().to_glib_none().0);
        }
    }

    /// Gets the data associated with a drag. When the data
    /// is received or the retrieval fails, GTK+ will emit a
    /// [`drag-data-received`][struct@crate::Widget#drag-data-received] signal. Failure of the retrieval
    /// is indicated by the length field of the `selection_data`
    /// signal parameter being negative. However, when [`drag_get_data()`][Self::drag_get_data()]
    /// is called implicitely because the [`DestDefaults::DROP`][crate::DestDefaults::DROP] was set,
    /// then the widget will not receive notification of failed
    /// drops.
    /// ## `context`
    /// the drag context
    /// ## `target`
    /// the target (form of the data) to retrieve
    /// ## `time_`
    /// a timestamp for retrieving the data. This will
    ///  generally be the time received in a [`drag-motion`][struct@crate::Widget#drag-motion]
    ///  or [`drag-drop`][struct@crate::Widget#drag-drop] signal
    #[doc(alias = "gtk_drag_get_data")]
    fn drag_get_data(&self, context: &gdk::DragContext, target: &gdk::Atom, time_: u32) {
        unsafe {
            ffi::gtk_drag_get_data(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                target.to_glib_none().0,
                time_,
            );
        }
    }

    /// Highlights a widget as a currently hovered drop target.
    /// To end the highlight, call [`drag_unhighlight()`][Self::drag_unhighlight()].
    /// GTK+ calls this automatically if [`DestDefaults::HIGHLIGHT`][crate::DestDefaults::HIGHLIGHT] is set.
    #[doc(alias = "gtk_drag_highlight")]
    fn drag_highlight(&self) {
        unsafe {
            ffi::gtk_drag_highlight(self.as_ref().to_glib_none().0);
        }
    }

    /// Add the writable image targets supported by [`SelectionData`][crate::SelectionData] to
    /// the target list of the drag source. The targets
    /// are added with `info` = 0. If you need another value,
    /// use [`TargetList::add_image_targets()`][crate::TargetList::add_image_targets()] and
    /// [`drag_source_set_target_list()`][Self::drag_source_set_target_list()].
    #[doc(alias = "gtk_drag_source_add_image_targets")]
    fn drag_source_add_image_targets(&self) {
        unsafe {
            ffi::gtk_drag_source_add_image_targets(self.as_ref().to_glib_none().0);
        }
    }

    /// Add the text targets supported by [`SelectionData`][crate::SelectionData] to
    /// the target list of the drag source. The targets
    /// are added with `info` = 0. If you need another value,
    /// use [`TargetList::add_text_targets()`][crate::TargetList::add_text_targets()] and
    /// [`drag_source_set_target_list()`][Self::drag_source_set_target_list()].
    #[doc(alias = "gtk_drag_source_add_text_targets")]
    fn drag_source_add_text_targets(&self) {
        unsafe {
            ffi::gtk_drag_source_add_text_targets(self.as_ref().to_glib_none().0);
        }
    }

    /// Add the URI targets supported by [`SelectionData`][crate::SelectionData] to
    /// the target list of the drag source. The targets
    /// are added with `info` = 0. If you need another value,
    /// use [`TargetList::add_uri_targets()`][crate::TargetList::add_uri_targets()] and
    /// [`drag_source_set_target_list()`][Self::drag_source_set_target_list()].
    #[doc(alias = "gtk_drag_source_add_uri_targets")]
    fn drag_source_add_uri_targets(&self) {
        unsafe {
            ffi::gtk_drag_source_add_uri_targets(self.as_ref().to_glib_none().0);
        }
    }

    /// Gets the list of targets this widget can provide for
    /// drag-and-drop.
    ///
    /// # Returns
    ///
    /// the [`TargetList`][crate::TargetList], or [`None`] if none
    #[doc(alias = "gtk_drag_source_get_target_list")]
    fn drag_source_get_target_list(&self) -> Option<TargetList> {
        unsafe {
            from_glib_none(ffi::gtk_drag_source_get_target_list(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the icon that will be used for drags from a particular source
    /// to `icon`. See the docs for [`IconTheme`][crate::IconTheme] for more details.
    /// ## `icon`
    /// A [`gio::Icon`][crate::gio::Icon]
    #[doc(alias = "gtk_drag_source_set_icon_gicon")]
    fn drag_source_set_icon_gicon(&self, icon: &impl IsA<gio::Icon>) {
        unsafe {
            ffi::gtk_drag_source_set_icon_gicon(
                self.as_ref().to_glib_none().0,
                icon.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the icon that will be used for drags from a particular source
    /// to a themed icon. See the docs for [`IconTheme`][crate::IconTheme] for more details.
    /// ## `icon_name`
    /// name of icon to use
    #[doc(alias = "gtk_drag_source_set_icon_name")]
    fn drag_source_set_icon_name(&self, icon_name: &str) {
        unsafe {
            ffi::gtk_drag_source_set_icon_name(
                self.as_ref().to_glib_none().0,
                icon_name.to_glib_none().0,
            );
        }
    }

    /// Sets the icon that will be used for drags from a particular widget
    /// from a [`gdk_pixbuf::Pixbuf`][crate::gdk_pixbuf::Pixbuf]. GTK+ retains a reference for `pixbuf` and will
    /// release it when it is no longer needed.
    /// ## `pixbuf`
    /// the [`gdk_pixbuf::Pixbuf`][crate::gdk_pixbuf::Pixbuf] for the drag icon
    #[doc(alias = "gtk_drag_source_set_icon_pixbuf")]
    fn drag_source_set_icon_pixbuf(&self, pixbuf: &gdk_pixbuf::Pixbuf) {
        unsafe {
            ffi::gtk_drag_source_set_icon_pixbuf(
                self.as_ref().to_glib_none().0,
                pixbuf.to_glib_none().0,
            );
        }
    }

    /// Changes the target types that this widget offers for drag-and-drop.
    /// The widget must first be made into a drag source with
    /// [`WidgetExtManual::drag_source_set()`][crate::prelude::WidgetExtManual::drag_source_set()].
    /// ## `target_list`
    /// list of draggable targets, or [`None`] for none
    #[doc(alias = "gtk_drag_source_set_target_list")]
    fn drag_source_set_target_list(&self, target_list: Option<&TargetList>) {
        unsafe {
            ffi::gtk_drag_source_set_target_list(
                self.as_ref().to_glib_none().0,
                target_list.to_glib_none().0,
            );
        }
    }

    /// Undoes the effects of [`WidgetExtManual::drag_source_set()`][crate::prelude::WidgetExtManual::drag_source_set()].
    #[doc(alias = "gtk_drag_source_unset")]
    fn drag_source_unset(&self) {
        unsafe {
            ffi::gtk_drag_source_unset(self.as_ref().to_glib_none().0);
        }
    }

    /// Removes a highlight set by [`drag_highlight()`][Self::drag_highlight()] from
    /// a widget.
    #[doc(alias = "gtk_drag_unhighlight")]
    fn drag_unhighlight(&self) {
        unsafe {
            ffi::gtk_drag_unhighlight(self.as_ref().to_glib_none().0);
        }
    }

    /// Draws `self` to `cr`. The top left corner of the widget will be
    /// drawn to the currently set origin point of `cr`.
    ///
    /// You should pass a cairo context as `cr` argument that is in an
    /// original state. Otherwise the resulting drawing is undefined. For
    /// example changing the operator using `cairo_set_operator()` or the
    /// line width using `cairo_set_line_width()` might have unwanted side
    /// effects.
    /// You may however change the context’s transform matrix - like with
    /// `cairo_scale()`, `cairo_translate()` or `cairo_set_matrix()` and clip
    /// region with `cairo_clip()` prior to calling this function. Also, it
    /// is fine to modify the context with `cairo_save()` and
    /// `cairo_push_group()` prior to calling this function.
    ///
    /// Note that special-purpose widgets may contain special code for
    /// rendering to the screen and might appear differently on screen
    /// and when rendered using [`draw()`][Self::draw()].
    /// ## `cr`
    /// a cairo context to draw to
    #[doc(alias = "gtk_widget_draw")]
    fn draw(&self, cr: &cairo::Context) {
        unsafe {
            ffi::gtk_widget_draw(
                self.as_ref().to_glib_none().0,
                mut_override(cr.to_glib_none().0),
            );
        }
    }

    /// Notifies the user about an input-related error on this widget.
    /// If the [`gtk-error-bell`][struct@crate::Settings#gtk-error-bell] setting is [`true`], it calls
    /// [`Window::beep()`][crate::gdk::Window::beep()], otherwise it does nothing.
    ///
    /// Note that the effect of [`Window::beep()`][crate::gdk::Window::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);
        }
    }

    /// Rarely-used function. This function is used to emit
    /// the event signals on a widget (those signals should never
    /// be emitted without using this function to do so).
    /// If you want to synthesize an event though, don’t use this function;
    /// instead, use [`main_do_event()`][crate::main_do_event()] so the event will behave as if
    /// it were in the event queue. Don’t synthesize expose events; instead,
    /// use [`Window::invalidate_rect()`][crate::gdk::Window::invalidate_rect()] to invalidate a region of the
    /// window.
    /// ## `event`
    /// a `GdkEvent`
    ///
    /// # Returns
    ///
    /// return from the event signal emission ([`true`] if
    ///  the event was handled)
    #[doc(alias = "gtk_widget_event")]
    fn event(&self, event: &gdk::Event) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_event(
                self.as_ref().to_glib_none().0,
                mut_override(event.to_glib_none().0),
            ))
        }
    }

    /// Stops emission of [`child-notify`][struct@crate::Widget#child-notify] signals on `self`. The
    /// signals are queued until [`thaw_child_notify()`][Self::thaw_child_notify()] is called
    /// on `self`.
    ///
    /// This is the analogue of [`ObjectExt::freeze_notify()`][crate::glib::prelude::ObjectExt::freeze_notify()] for child properties.
    #[doc(alias = "gtk_widget_freeze_child_notify")]
    fn freeze_child_notify(&self) {
        unsafe {
            ffi::gtk_widget_freeze_child_notify(self.as_ref().to_glib_none().0);
        }
    }

    /// Returns the accessible object that describes the widget to an
    /// assistive technology.
    ///
    /// If accessibility support is not available, this [`atk::Object`][crate::atk::Object]
    /// instance may be a no-op. Likewise, if no class-specific [`atk::Object`][crate::atk::Object]
    /// implementation is available for the widget instance in question,
    /// it will inherit an [`atk::Object`][crate::atk::Object] implementation from the first ancestor
    /// class for which such an implementation is defined.
    ///
    /// The documentation of the
    /// [ATK](http://developer.gnome.org/atk/stable/)
    /// library contains more information about accessible objects and their uses.
    ///
    /// # Returns
    ///
    /// the [`atk::Object`][crate::atk::Object] associated with `self`
    #[doc(alias = "gtk_widget_get_accessible")]
    #[doc(alias = "get_accessible")]
    fn accessible(&self) -> Option<atk::Object> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_accessible(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves the [`gio::ActionGroup`][crate::gio::ActionGroup] that was registered using `prefix`. The resulting
    /// [`gio::ActionGroup`][crate::gio::ActionGroup] may have been registered to `self` or any [`Widget`][crate::Widget] in its
    /// ancestry.
    ///
    /// If no action group was found matching `prefix`, then [`None`] is returned.
    /// ## `prefix`
    /// The “prefix” of the action group.
    ///
    /// # Returns
    ///
    /// A [`gio::ActionGroup`][crate::gio::ActionGroup] or [`None`].
    #[doc(alias = "gtk_widget_get_action_group")]
    #[doc(alias = "get_action_group")]
    fn action_group(&self, prefix: &str) -> Option<gio::ActionGroup> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_action_group(
                self.as_ref().to_glib_none().0,
                prefix.to_glib_none().0,
            ))
        }
    }

    /// Returns the baseline that has currently been allocated to `self`.
    /// This function is intended to be used when implementing handlers
    /// for the [`draw`][struct@crate::Widget#draw] function, and when allocating child
    /// widgets in [`size_allocate`][struct@crate::Widget#size_allocate].
    ///
    /// # Returns
    ///
    /// the baseline of the `self`, or -1 if none
    #[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 `self`.
    /// This function is intended to be used when implementing handlers
    /// for the [`draw`][struct@crate::Widget#draw] function.
    ///
    /// # Returns
    ///
    /// the height of the `self`
    #[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) }
    }

    /// Retrieves the widget’s allocated size.
    ///
    /// This function returns the last values passed to
    /// [`size_allocate_with_baseline()`][Self::size_allocate_with_baseline()]. The value differs from
    /// the size returned in [`allocation()`][Self::allocation()] in that functions
    /// like [`set_halign()`][Self::set_halign()] can adjust the allocation, but not
    /// the value returned by this function.
    ///
    /// If a widget is not visible, its allocated size is 0.
    ///
    /// # Returns
    ///
    ///
    /// ## `allocation`
    /// a pointer to a `GtkAllocation` to copy to
    ///
    /// ## `baseline`
    /// a pointer to an integer to copy to
    #[doc(alias = "gtk_widget_get_allocated_size")]
    #[doc(alias = "get_allocated_size")]
    fn allocated_size(&self) -> (Allocation, i32) {
        unsafe {
            let mut allocation = Allocation::uninitialized();
            let mut baseline = mem::MaybeUninit::uninit();
            ffi::gtk_widget_get_allocated_size(
                self.as_ref().to_glib_none().0,
                allocation.to_glib_none_mut().0,
                baseline.as_mut_ptr(),
            );
            (allocation, baseline.assume_init())
        }
    }

    /// Returns the width that has currently been allocated to `self`.
    /// This function is intended to be used when implementing handlers
    /// for the [`draw`][struct@crate::Widget#draw] function.
    ///
    /// # Returns
    ///
    /// the width of the `self`
    #[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 [`Container`][crate::Container]: a widget’s allocation will
    /// be its “adjusted” allocation, that is, the widget’s parent
    /// container 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 [`Container`][crate::Container]
    /// is guaranteed that its children stay inside the assigned bounds,
    /// but not that they have exactly the bounds the container assigned.
    /// There is no way to get the original allocation assigned by
    /// [`size_allocate()`][Self::size_allocate()], since it isn’t stored; if a container
    /// implementation needs that information it will have to track it itself.
    ///
    /// # Returns
    ///
    ///
    /// ## `allocation`
    /// a pointer to a `GtkAllocation` to copy to
    #[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 `self` 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. See note
    /// about checking for a toplevel [`Window`][crate::Window] in the docs for
    /// [`toplevel()`][Self::toplevel()].
    ///
    /// Note that unlike [`is_ancestor()`][Self::is_ancestor()], [`ancestor()`][Self::ancestor()]
    /// considers `self` to be an ancestor of itself.
    /// ## `widget_type`
    /// ancestor type
    ///
    /// # Returns
    ///
    /// the ancestor widget, or [`None`] if not found
    #[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(),
            ))
        }
    }

    /// Determines whether the application intends to draw on the widget in
    /// an [`draw`][struct@crate::Widget#draw] handler.
    ///
    /// See [`set_app_paintable()`][Self::set_app_paintable()]
    ///
    /// # Returns
    ///
    /// [`true`] if the widget is app paintable
    #[doc(alias = "gtk_widget_get_app_paintable")]
    #[doc(alias = "get_app_paintable")]
    fn is_app_paintable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_app_paintable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` can be a default widget. See
    /// [`set_can_default()`][Self::set_can_default()].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` can be a default widget, [`false`] otherwise
    #[doc(alias = "gtk_widget_get_can_default")]
    #[doc(alias = "get_can_default")]
    fn can_default(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_can_default(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` can own the input focus. See
    /// [`set_can_focus()`][Self::set_can_focus()].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` can own the input focus, [`false`] otherwise
    #[doc(alias = "gtk_widget_get_can_focus")]
    #[doc(alias = "get_can_focus")]
    fn can_focus(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_can_focus(
                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 container implementations and
    /// never should 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,
            ))
        }
    }

    /// Retrieves the widget’s clip area.
    ///
    /// The clip area is the area in which all of `self`'s drawing will
    /// happen. Other toolkits call it the bounding box.
    ///
    /// Historically, in GTK+ the clip area has been equal to the allocation
    /// retrieved via [`allocation()`][Self::allocation()].
    ///
    /// # Returns
    ///
    ///
    /// ## `clip`
    /// a pointer to a `GtkAllocation` to copy to
    #[doc(alias = "gtk_widget_get_clip")]
    #[doc(alias = "get_clip")]
    fn clip(&self) -> Allocation {
        unsafe {
            let mut clip = Allocation::uninitialized();
            ffi::gtk_widget_get_clip(self.as_ref().to_glib_none().0, clip.to_glib_none_mut().0);
            clip
        }
    }

    /// Returns the clipboard object for the given selection to
    /// be used with `self`. `self` must have a [`gdk::Display`][crate::gdk::Display]
    /// associated with it, so must be attached to a toplevel
    /// window.
    /// ## `selection`
    /// a [`gdk::Atom`][crate::gdk::Atom] which identifies the clipboard
    ///  to use. `GDK_SELECTION_CLIPBOARD` gives the
    ///  default clipboard. Another common value
    ///  is `GDK_SELECTION_PRIMARY`, which gives
    ///  the primary X selection.
    ///
    /// # Returns
    ///
    /// the appropriate clipboard object. If no
    ///  clipboard already exists, a new one will
    ///  be created. Once a clipboard object has
    ///  been created, it is persistent for all time.
    #[doc(alias = "gtk_widget_get_clipboard")]
    #[doc(alias = "get_clipboard")]
    fn clipboard(&self, selection: &gdk::Atom) -> Clipboard {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_clipboard(
                self.as_ref().to_glib_none().0,
                selection.to_glib_none().0,
            ))
        }
    }

    /// Returns whether `device` can interact with `self` and its
    /// children. See [`set_device_enabled()`][Self::set_device_enabled()].
    /// ## `device`
    /// a [`gdk::Device`][crate::gdk::Device]
    ///
    /// # Returns
    ///
    /// [`true`] is `device` is enabled for `self`
    #[doc(alias = "gtk_widget_get_device_enabled")]
    #[doc(alias = "get_device_enabled")]
    fn device_is_enabled(&self, device: &gdk::Device) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_device_enabled(
                self.as_ref().to_glib_none().0,
                device.to_glib_none().0,
            ))
        }
    }

    /// Returns the events mask for the widget corresponding to an specific device. These
    /// are the events that the widget will receive when `device` operates on it.
    /// ## `device`
    /// a [`gdk::Device`][crate::gdk::Device]
    ///
    /// # Returns
    ///
    /// device event mask for `self`
    #[doc(alias = "gtk_widget_get_device_events")]
    #[doc(alias = "get_device_events")]
    fn device_events(&self, device: &gdk::Device) -> gdk::EventMask {
        unsafe {
            from_glib(ffi::gtk_widget_get_device_events(
                self.as_ref().to_glib_none().0,
                device.to_glib_none().0,
            ))
        }
    }

    /// Gets the reading direction for a particular 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 [`gdk::Display`][crate::gdk::Display] for the toplevel window associated with
    /// this widget. This function can only be called after the widget
    /// has been added to a widget hierarchy with a [`Window`][crate::Window] 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 [`gdk::Display`][crate::gdk::Display] for the toplevel 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)) }
    }

    /// Determines whether the widget is double buffered.
    ///
    /// See `gtk_widget_set_double_buffered()`
    ///
    /// # Returns
    ///
    /// [`true`] if the widget is double buffered
    #[doc(alias = "gtk_widget_get_double_buffered")]
    #[doc(alias = "get_double_buffered")]
    fn is_double_buffered(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_double_buffered(
                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")]
    fn gets_focus_on_click(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_focus_on_click(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the font map that has been set with [`set_font_map()`][Self::set_font_map()].
    ///
    /// # Returns
    ///
    /// A [`pango::FontMap`][crate::pango::FontMap], or [`None`]
    #[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] used for Pango rendering. When not set,
    /// the defaults font options for the [`gdk::Screen`][crate::gdk::Screen] will be used.
    ///
    /// # Returns
    ///
    /// the [`cairo::FontOptions`][crate::cairo::FontOptions] or [`None`] if not set
    #[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
    ///
    /// a [`gdk::FrameClock`][crate::gdk::FrameClock],
    /// or [`None`] if widget is unrealized
    #[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 value of the [`halign`][struct@crate::Widget#halign] property.
    ///
    /// For backwards compatibility reasons this method will never return
    /// [`Align::Baseline`][crate::Align::Baseline], but instead it will convert it to
    /// [`Align::Fill`][crate::Align::Fill]. 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. See
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] for more information.
    ///
    /// # Returns
    ///
    /// current value of has-tooltip on `self`.
    #[doc(alias = "gtk_widget_get_has_tooltip")]
    #[doc(alias = "get_has_tooltip")]
    fn has_tooltip(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_has_tooltip(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether `self` has a [`gdk::Window`][crate::gdk::Window] of its own. See
    /// [`set_has_window()`][Self::set_has_window()].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` has a window, [`false`] otherwise
    #[doc(alias = "gtk_widget_get_has_window")]
    #[doc(alias = "get_has_window")]
    fn has_window(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_has_window(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether the widget would like any available extra horizontal
    /// space. When a user resizes a [`Window`][crate::Window], widgets with expand=TRUE
    /// generally receive the extra space. For example, a list or
    /// scrollable area or document in your window would often be set to
    /// expand.
    ///
    /// Containers should use [`compute_expand()`][Self::compute_expand()] rather than
    /// this function, to see whether a widget, or 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")]
    fn hexpands(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_hexpand(self.as_ref().to_glib_none().0)) }
    }

    /// Gets whether [`set_hexpand()`][Self::set_hexpand()] has been used to
    /// explicitly set the expand flag on this widget.
    ///
    /// 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.
    ///
    /// # Returns
    ///
    /// whether hexpand has been explicitly set
    #[doc(alias = "gtk_widget_get_hexpand_set")]
    #[doc(alias = "get_hexpand_set")]
    fn is_hexpand_set(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_hexpand_set(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Whether the widget is mapped.
    ///
    /// # Returns
    ///
    /// [`true`] if the widget is mapped, [`false`] otherwise.
    #[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 value of the [`margin-bottom`][struct@crate::Widget#margin-bottom] property.
    ///
    /// # Returns
    ///
    /// The bottom margin of `self`
    #[doc(alias = "gtk_widget_get_margin_bottom")]
    #[doc(alias = "get_margin_bottom")]
    fn margin_bottom(&self) -> i32 {
        unsafe { ffi::gtk_widget_get_margin_bottom(self.as_ref().to_glib_none().0) }
    }

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

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

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

    /// Returns the modifier mask the `self`’s windowing system backend
    /// uses for a particular purpose.
    ///
    /// See `gdk_keymap_get_modifier_mask()`.
    /// ## `intent`
    /// the use case for the modifier mask
    ///
    /// # Returns
    ///
    /// the modifier mask used for `intent`.
    #[doc(alias = "gtk_widget_get_modifier_mask")]
    #[doc(alias = "get_modifier_mask")]
    fn modifier_mask(&self, intent: gdk::ModifierIntent) -> gdk::ModifierType {
        unsafe {
            from_glib(ffi::gtk_widget_get_modifier_mask(
                self.as_ref().to_glib_none().0,
                intent.into_glib(),
            ))
        }
    }

    /// 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. This string is owned by GTK+ and
    /// should not be modified or freed
    #[doc(alias = "gtk_widget_get_name")]
    #[doc(alias = "get_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 current value of the [`no-show-all`][struct@crate::Widget#no-show-all] property,
    /// which determines whether calls to [`show_all()`][Self::show_all()]
    /// will affect this widget.
    ///
    /// # Returns
    ///
    /// the current value of the “no-show-all” property.
    #[doc(alias = "gtk_widget_get_no_show_all")]
    #[doc(alias = "get_no_show_all")]
    fn is_no_show_all(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_no_show_all(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Fetches the requested opacity for this 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) }
    }

    /// Gets a [`pango::Context`][crate::pango::Context] with the appropriate font map, font description,
    /// and base direction for this widget. 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 using the [`screen-changed`][struct@crate::Widget#screen-changed] signal 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 container of `self`.
    ///
    /// # Returns
    ///
    /// the parent container of `self`, or [`None`]
    #[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)) }
    }

    /// Gets `self`’s parent window, or [`None`] if it does not have one.
    ///
    /// # Returns
    ///
    /// the parent window of `self`, or [`None`]
    /// if it does not have a parent window.
    #[doc(alias = "gtk_widget_get_parent_window")]
    #[doc(alias = "get_parent_window")]
    fn parent_window(&self) -> Option<gdk::Window> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_parent_window(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the [`WidgetPath`][crate::WidgetPath] representing `self`, if the widget
    /// is not connected to a toplevel widget, a partial path will be
    /// created.
    ///
    /// # Returns
    ///
    /// The [`WidgetPath`][crate::WidgetPath] representing `self`
    #[doc(alias = "gtk_widget_get_path")]
    #[doc(alias = "get_path")]
    fn path(&self) -> WidgetPath {
        unsafe { from_glib_none(ffi::gtk_widget_get_path(self.as_ref().to_glib_none().0)) }
    }

    /// Retrieves a widget’s initial minimum and natural height.
    ///
    /// This call is specific to width-for-height requests.
    ///
    /// The returned request will be modified by the
    /// GtkWidgetClass::adjust_size_request virtual method and by any
    /// `GtkSizeGroups` that have been applied. That is, the returned request
    /// is the one that should be used for layout, not necessarily the one
    /// returned by the widget itself.
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_height`
    /// location to store the minimum height, or [`None`]
    ///
    /// ## `natural_height`
    /// location to store the natural height, or [`None`]
    #[doc(alias = "gtk_widget_get_preferred_height")]
    #[doc(alias = "get_preferred_height")]
    fn preferred_height(&self) -> (i32, i32) {
        unsafe {
            let mut minimum_height = mem::MaybeUninit::uninit();
            let mut natural_height = mem::MaybeUninit::uninit();
            ffi::gtk_widget_get_preferred_height(
                self.as_ref().to_glib_none().0,
                minimum_height.as_mut_ptr(),
                natural_height.as_mut_ptr(),
            );
            (minimum_height.assume_init(), natural_height.assume_init())
        }
    }

    /// Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
    /// the specified `width`, or the default height if `width` is -1. The baselines may be -1 which means
    /// that no baseline is requested for this widget.
    ///
    /// The returned request will be modified by the
    /// GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
    /// and by any `GtkSizeGroups` that have been applied. That is, the returned request
    /// is the one that should be used for layout, not necessarily the one
    /// returned by the widget itself.
    /// ## `width`
    /// the width which is available for allocation, or -1 if none
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_height`
    /// location for storing the minimum height, or [`None`]
    ///
    /// ## `natural_height`
    /// location for storing the natural height, or [`None`]
    ///
    /// ## `minimum_baseline`
    /// location for storing the baseline for the minimum height, or [`None`]
    ///
    /// ## `natural_baseline`
    /// location for storing the baseline for the natural height, or [`None`]
    #[doc(alias = "gtk_widget_get_preferred_height_and_baseline_for_width")]
    #[doc(alias = "get_preferred_height_and_baseline_for_width")]
    fn preferred_height_and_baseline_for_width(&self, width: i32) -> (i32, i32, i32, i32) {
        unsafe {
            let mut minimum_height = mem::MaybeUninit::uninit();
            let mut natural_height = mem::MaybeUninit::uninit();
            let mut minimum_baseline = mem::MaybeUninit::uninit();
            let mut natural_baseline = mem::MaybeUninit::uninit();
            ffi::gtk_widget_get_preferred_height_and_baseline_for_width(
                self.as_ref().to_glib_none().0,
                width,
                minimum_height.as_mut_ptr(),
                natural_height.as_mut_ptr(),
                minimum_baseline.as_mut_ptr(),
                natural_baseline.as_mut_ptr(),
            );
            (
                minimum_height.assume_init(),
                natural_height.assume_init(),
                minimum_baseline.assume_init(),
                natural_baseline.assume_init(),
            )
        }
    }

    /// Retrieves a widget’s minimum and natural height if it would be given
    /// the specified `width`.
    ///
    /// The returned request will be modified by the
    /// GtkWidgetClass::adjust_size_request virtual method and by any
    /// `GtkSizeGroups` that have been applied. That is, the returned request
    /// is the one that should be used for layout, not necessarily the one
    /// returned by the widget itself.
    /// ## `width`
    /// the width which is available for allocation
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_height`
    /// location for storing the minimum height, or [`None`]
    ///
    /// ## `natural_height`
    /// location for storing the natural height, or [`None`]
    #[doc(alias = "gtk_widget_get_preferred_height_for_width")]
    #[doc(alias = "get_preferred_height_for_width")]
    fn preferred_height_for_width(&self, width: i32) -> (i32, i32) {
        unsafe {
            let mut minimum_height = mem::MaybeUninit::uninit();
            let mut natural_height = mem::MaybeUninit::uninit();
            ffi::gtk_widget_get_preferred_height_for_width(
                self.as_ref().to_glib_none().0,
                width,
                minimum_height.as_mut_ptr(),
                natural_height.as_mut_ptr(),
            );
            (minimum_height.assume_init(), natural_height.assume_init())
        }
    }

    /// 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 GtkLayout.
    ///
    /// 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 [`preferred_height_and_baseline_for_width()`][Self::preferred_height_and_baseline_for_width()] if you want to support
    /// baseline alignment.
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_size`
    /// location for storing the minimum size, or [`None`]
    ///
    /// ## `natural_size`
    /// location for storing the natural size, or [`None`]
    #[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)
        }
    }

    /// Retrieves a widget’s initial minimum and natural width.
    ///
    /// This call is specific to height-for-width requests.
    ///
    /// The returned request will be modified by the
    /// GtkWidgetClass::adjust_size_request virtual method and by any
    /// `GtkSizeGroups` that have been applied. That is, the returned request
    /// is the one that should be used for layout, not necessarily the one
    /// returned by the widget itself.
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_width`
    /// location to store the minimum width, or [`None`]
    ///
    /// ## `natural_width`
    /// location to store the natural width, or [`None`]
    #[doc(alias = "gtk_widget_get_preferred_width")]
    #[doc(alias = "get_preferred_width")]
    fn preferred_width(&self) -> (i32, i32) {
        unsafe {
            let mut minimum_width = mem::MaybeUninit::uninit();
            let mut natural_width = mem::MaybeUninit::uninit();
            ffi::gtk_widget_get_preferred_width(
                self.as_ref().to_glib_none().0,
                minimum_width.as_mut_ptr(),
                natural_width.as_mut_ptr(),
            );
            (minimum_width.assume_init(), natural_width.assume_init())
        }
    }

    /// Retrieves a widget’s minimum and natural width if it would be given
    /// the specified `height`.
    ///
    /// The returned request will be modified by the
    /// GtkWidgetClass::adjust_size_request virtual method and by any
    /// `GtkSizeGroups` that have been applied. That is, the returned request
    /// is the one that should be used for layout, not necessarily the one
    /// returned by the widget itself.
    /// ## `height`
    /// the height which is available for allocation
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_width`
    /// location for storing the minimum width, or [`None`]
    ///
    /// ## `natural_width`
    /// location for storing the natural width, or [`None`]
    #[doc(alias = "gtk_widget_get_preferred_width_for_height")]
    #[doc(alias = "get_preferred_width_for_height")]
    fn preferred_width_for_height(&self, height: i32) -> (i32, i32) {
        unsafe {
            let mut minimum_width = mem::MaybeUninit::uninit();
            let mut natural_width = mem::MaybeUninit::uninit();
            ffi::gtk_widget_get_preferred_width_for_height(
                self.as_ref().to_glib_none().0,
                height,
                minimum_width.as_mut_ptr(),
                natural_width.as_mut_ptr(),
            );
            (minimum_width.assume_init(), natural_width.assume_init())
        }
    }

    /// Determines whether `self` is realized.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is realized, [`false`] otherwise
    #[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 `self` 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,
    ///  [`false`] otherwise
    #[doc(alias = "gtk_widget_get_receives_default")]
    #[doc(alias = "get_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.
    ///
    /// [`Bin`][crate::Bin] widgets generally propagate the preference of
    /// their child, container 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,
            ))
        }
    }

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

    /// Get the [`gdk::Screen`][crate::gdk::Screen] from the toplevel window associated with
    /// this widget. This function can only be called after the widget
    /// has been added to a widget hierarchy with a [`Window`][crate::Window]
    /// at the top.
    ///
    /// In general, you should only create screen specific
    /// resources when a widget has been realized, and you should
    /// free those resources when the widget is unrealized.
    ///
    /// # Returns
    ///
    /// the [`gdk::Screen`][crate::gdk::Screen] for the toplevel for this widget.
    #[doc(alias = "gtk_widget_get_screen")]
    #[doc(alias = "get_screen")]
    fn screen(&self) -> Option<gdk::Screen> {
        unsafe { from_glib_none(ffi::gtk_widget_get_screen(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the widget’s sensitivity (in the sense of returning
    /// 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")]
    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 this 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 [`gdk::Screen`][crate::gdk::Screen].
    ///
    /// # Returns
    ///
    /// the relevant [`Settings`][crate::Settings] object
    #[doc(alias = "gtk_widget_get_settings")]
    #[doc(alias = "get_settings")]
    fn settings(&self) -> Option<Settings> {
        unsafe { from_glib_none(ffi::gtk_widget_get_settings(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the size request that was explicitly set for the widget using
    /// [`set_size_request()`][Self::set_size_request()]. 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 [`preferred_size()`][Self::preferred_size()] instead of
    /// this function.
    ///
    /// # Returns
    ///
    ///
    /// ## `width`
    /// return location for width, or [`None`]
    ///
    /// ## `height`
    /// return location for height, or [`None`]
    #[doc(alias = "gtk_widget_get_size_request")]
    #[doc(alias = "get_size_request")]
    fn size_request(&self) -> (i32, i32) {
        unsafe {
            let mut width = mem::MaybeUninit::uninit();
            let mut height = 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 [`StateFlags::INSENSITIVE`][crate::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 for 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 `self`. The returned object is
    /// guaranteed to be the same for the lifetime of `self`.
    ///
    /// # Returns
    ///
    /// a [`StyleContext`][crate::StyleContext]. This memory is owned by `self` and
    ///  must not be freed.
    #[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,
            ))
        }
    }

    /// Returns [`true`] if `self` is multiple pointer aware. See
    /// [`set_support_multidevice()`][Self::set_support_multidevice()] for more information.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is multidevice aware.
    #[doc(alias = "gtk_widget_get_support_multidevice")]
    #[doc(alias = "get_support_multidevice")]
    fn supports_multidevice(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_get_support_multidevice(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Fetch an object build from the template XML for `widget_type` in this `self` instance.
    ///
    /// This will only report children which were previously declared with
    /// `gtk_widget_class_bind_template_child_full()` or one of its
    /// variants.
    ///
    /// This function is only meant to be called for code which is private to the `widget_type` which
    /// declared the child and is meant for language bindings which cannot easily make use
    /// of the GObject structure offsets.
    /// ## `widget_type`
    /// The `GType` to get a template child for
    /// ## `name`
    /// The “id” of the child defined in the template XML
    ///
    /// # Returns
    ///
    /// The object built in the template XML with the id `name`
    #[doc(alias = "gtk_widget_get_template_child")]
    #[doc(alias = "get_template_child")]
    fn template_child(&self, widget_type: glib::types::Type, name: &str) -> Option<glib::Object> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_template_child(
                self.as_ref().to_glib_none().0,
                widget_type.into_glib(),
                name.to_glib_none().0,
            ))
        }
    }

    /// Gets the contents of the tooltip for `self`.
    ///
    /// # Returns
    ///
    /// the tooltip text, or [`None`]. You should free the
    ///  returned string with `g_free()` when done.
    #[doc(alias = "gtk_widget_get_tooltip_markup")]
    #[doc(alias = "get_tooltip_markup")]
    fn tooltip_markup(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_widget_get_tooltip_markup(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the contents of the tooltip for `self`.
    ///
    /// # Returns
    ///
    /// the tooltip text, or [`None`]. You should free the
    ///  returned string with `g_free()` when done.
    #[doc(alias = "gtk_widget_get_tooltip_text")]
    #[doc(alias = "get_tooltip_text")]
    fn tooltip_text(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_widget_get_tooltip_text(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the [`Window`][crate::Window] of the current tooltip. This can be the
    /// GtkWindow created by default, or the custom tooltip window set
    /// using [`set_tooltip_window()`][Self::set_tooltip_window()].
    ///
    /// # Returns
    ///
    /// The [`Window`][crate::Window] of the current tooltip.
    #[doc(alias = "gtk_widget_get_tooltip_window")]
    #[doc(alias = "get_tooltip_window")]
    fn tooltip_window(&self) -> Option<Window> {
        unsafe {
            from_glib_none(ffi::gtk_widget_get_tooltip_window(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// This function returns the topmost widget in the container hierarchy
    /// `self` is a part of. If `self` has no parent widgets, it will be
    /// returned as the topmost widget. No reference will be added to the
    /// returned widget; it should not be unreferenced.
    ///
    /// Note the difference in behavior vs. [`ancestor()`][Self::ancestor()];
    /// `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
    /// would return
    /// [`None`] if `self` wasn’t inside a toplevel window, and if the
    /// window was inside a [`Window`][crate::Window]-derived widget which was in turn
    /// inside the toplevel [`Window`][crate::Window]. While the second case may
    /// seem unlikely, it actually happens when a [`Plug`][crate::Plug] is embedded
    /// inside a [`Socket`][crate::Socket] within the same application.
    ///
    /// To reliably find the toplevel [`Window`][crate::Window], use
    /// [`toplevel()`][Self::toplevel()] and call GTK_IS_WINDOW()
    /// on the result. For instance, to get the title of a widget's toplevel
    /// window, one might use:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static const char *
    /// get_widget_toplevel_title (GtkWidget *widget)
    /// {
    ///   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
    ///   if (GTK_IS_WINDOW (toplevel))
    ///     {
    ///       return gtk_window_get_title (GTK_WINDOW (toplevel));
    ///     }
    ///
    ///   return NULL;
    /// }
    /// ```
    ///
    /// # Returns
    ///
    /// the topmost ancestor of `self`, or `self` itself
    ///  if there’s no ancestor.
    #[doc(alias = "gtk_widget_get_toplevel")]
    #[doc(alias = "get_toplevel")]
    #[must_use]
    fn toplevel(&self) -> Option<Widget> {
        unsafe { from_glib_none(ffi::gtk_widget_get_toplevel(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the value of the [`valign`][struct@crate::Widget#valign] property.
    ///
    /// For backwards compatibility reasons this method will never return
    /// [`Align::Baseline`][crate::Align::Baseline], but instead it will convert it to
    /// [`Align::Fill`][crate::Align::Fill]. If your widget want to support baseline aligned
    /// children it must use [`valign_with_baseline()`][Self::valign_with_baseline()], or
    /// `g_object_get (widget, "valign", &value, NULL)`, which will
    /// also report the true value.
    ///
    /// # Returns
    ///
    /// the vertical alignment of `self`, ignoring baseline alignment
    #[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 the value of the [`valign`][struct@crate::Widget#valign] property, including
    /// [`Align::Baseline`][crate::Align::Baseline].
    ///
    /// # Returns
    ///
    /// the vertical alignment of `self`
    #[doc(alias = "gtk_widget_get_valign_with_baseline")]
    #[doc(alias = "get_valign_with_baseline")]
    fn valign_with_baseline(&self) -> Align {
        unsafe {
            from_glib(ffi::gtk_widget_get_valign_with_baseline(
                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")]
    fn vexpands(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_vexpand(self.as_ref().to_glib_none().0)) }
    }

    /// Gets whether [`set_vexpand()`][Self::set_vexpand()] has been used to
    /// explicitly set the expand flag on this widget.
    ///
    /// 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")]
    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")]
    fn get_visible(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_get_visible(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the visual that will be used to render `self`.
    ///
    /// # Returns
    ///
    /// the visual for `self`
    #[doc(alias = "gtk_widget_get_visual")]
    #[doc(alias = "get_visual")]
    fn visual(&self) -> Option<gdk::Visual> {
        unsafe { from_glib_none(ffi::gtk_widget_get_visual(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the widget’s window if it is realized, [`None`] otherwise
    ///
    /// # Returns
    ///
    /// `self`’s window.
    #[doc(alias = "gtk_widget_get_window")]
    #[doc(alias = "get_window")]
    fn window(&self) -> Option<gdk::Window> {
        unsafe { from_glib_none(ffi::gtk_widget_get_window(self.as_ref().to_glib_none().0)) }
    }

    /// Makes `self` the current grabbed widget.
    ///
    /// This means that interaction with other widgets in the same
    /// application is blocked and mouse as well as keyboard events
    /// are delivered to this widget.
    ///
    /// If `self` is not sensitive, it is not set as the current
    /// grabbed widget and this function does nothing.
    #[doc(alias = "gtk_grab_add")]
    fn grab_add(&self) {
        unsafe {
            ffi::gtk_grab_add(self.as_ref().to_glib_none().0);
        }
    }

    /// Causes `self` to become the default widget. `self` must be able to be
    /// a default widget; typically you would ensure this yourself
    /// by calling [`set_can_default()`][Self::set_can_default()] with a [`true`] value.
    /// The default widget is activated when
    /// the user presses Enter in a window. Default widgets must be
    /// activatable, that is, [`activate()`][Self::activate()] should affect them. Note
    /// that [`Entry`][crate::Entry] widgets require the “activates-default” property
    /// set to [`true`] before they activate the default widget when Enter
    /// is pressed and the [`Entry`][crate::Entry] is focused.
    #[doc(alias = "gtk_widget_grab_default")]
    fn grab_default(&self) {
        unsafe {
            ffi::gtk_widget_grab_default(self.as_ref().to_glib_none().0);
        }
    }

    /// Causes `self` to have the keyboard focus for the [`Window`][crate::Window] it's
    /// inside. `self` must be a focusable widget, such as a [`Entry`][crate::Entry];
    /// something like [`Frame`][crate::Frame] won’t work.
    ///
    /// More precisely, it must have the `GTK_CAN_FOCUS` flag set. Use
    /// [`set_can_focus()`][Self::set_can_focus()] to modify that flag.
    ///
    /// The widget also needs to be realized and mapped. This is indicated by the
    /// related signals. Grabbing the focus immediately after creating the widget
    /// will likely fail and cause critical warnings.
    #[doc(alias = "gtk_widget_grab_focus")]
    fn grab_focus(&self) {
        unsafe {
            ffi::gtk_widget_grab_focus(self.as_ref().to_glib_none().0);
        }
    }

    /// Removes the grab from the given widget.
    ///
    /// You have to pair calls to [`grab_add()`][Self::grab_add()] and [`grab_remove()`][Self::grab_remove()].
    ///
    /// If `self` does not have the grab, this function does nothing.
    #[doc(alias = "gtk_grab_remove")]
    fn grab_remove(&self) {
        unsafe {
            ffi::gtk_grab_remove(self.as_ref().to_glib_none().0);
        }
    }

    /// Determines whether `self` is the current default widget within its
    /// toplevel. See [`set_can_default()`][Self::set_can_default()].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is the current default widget within
    ///  its toplevel, [`false`] otherwise
    #[doc(alias = "gtk_widget_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")]
    fn has_focus(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_has_focus(self.as_ref().to_glib_none().0)) }
    }

    /// Determines whether the widget is currently grabbing events, so it
    /// is the only widget receiving input events (keyboard and mouse).
    ///
    /// See also [`grab_add()`][Self::grab_add()].
    ///
    /// # Returns
    ///
    /// [`true`] if the widget is in the grab_widgets stack
    #[doc(alias = "gtk_widget_has_grab")]
    fn has_grab(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_has_grab(self.as_ref().to_glib_none().0)) }
    }

    /// Checks whether there is a [`gdk::Screen`][crate::gdk::Screen] is associated with
    /// this widget. All toplevel widgets have an associated
    /// screen, and all widgets added into a hierarchy with a toplevel
    /// window at the top.
    ///
    /// # Returns
    ///
    /// [`true`] if there is a [`gdk::Screen`][crate::gdk::Screen] associated
    ///  with the widget.
    #[doc(alias = "gtk_widget_has_screen")]
    fn has_screen(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_has_screen(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 for
    /// use in ::draw handlers 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 [`show()`][Self::show()], causing the widget to be
    /// hidden (invisible to the user).
    #[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,
            ))
        }
    }

    /// Creates and initializes child widgets defined in templates. This
    /// function must be called in the instance initializer for any
    /// class which assigned itself a template using `gtk_widget_class_set_template()`
    ///
    /// It is important to call this function in the instance initializer
    /// of a [`Widget`][crate::Widget] subclass and not in `GObject.constructed()` or
    /// `GObject.constructor()` for two reasons.
    ///
    /// One reason is that generally derived widgets will assume that parent
    /// class composite widgets have been created in their instance
    /// initializers.
    ///
    /// Another reason is that when calling [`glib::Object::new()`][crate::glib::Object::new()] on a widget with
    /// composite templates, it’s important to build the composite widgets
    /// before the construct properties are set. Properties passed to [`glib::Object::new()`][crate::glib::Object::new()]
    /// should take precedence over properties set in the private template XML.
    #[doc(alias = "gtk_widget_init_template")]
    fn init_template(&self) {
        unsafe {
            ffi::gtk_widget_init_template(self.as_ref().to_glib_none().0);
        }
    }

    /// Sets an input shape for this widget’s GDK window. This allows for
    /// windows which react to mouse click in a nonrectangular region, see
    /// [`Window::input_shape_combine_region()`][crate::gdk::Window::input_shape_combine_region()] for more information.
    /// ## `region`
    /// shape to be added, or [`None`] to remove an existing shape
    #[doc(alias = "gtk_widget_input_shape_combine_region")]
    fn input_shape_combine_region(&self, region: Option<&cairo::Region>) {
        unsafe {
            ffi::gtk_widget_input_shape_combine_region(
                self.as_ref().to_glib_none().0,
                mut_override(region.to_glib_none().0),
            );
        }
    }

    /// Inserts `group` into `self`. 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`.
    ///
    /// If `group` is [`None`], a previously inserted group for `name` is removed
    /// from `self`.
    /// ## `name`
    /// the prefix for actions in `group`
    /// ## `group`
    /// a [`gio::ActionGroup`][crate::gio::ActionGroup], or [`None`]
    #[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,
            );
        }
    }

    /// Determines whether `self` is somewhere inside `ancestor`, possibly with
    /// intermediate containers.
    /// ## `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 `self` can be drawn to. A widget can be drawn
    /// to if it is mapped and visible.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is drawable, [`false`] otherwise
    #[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, which 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 `self` is a toplevel widget.
    ///
    /// Currently only [`Window`][crate::Window] and [`Invisible`][crate::Invisible] (and out-of-process
    /// `GtkPlugs`) are toplevel widgets. Toplevel widgets have no parent
    /// widget.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is a toplevel, [`false`] otherwise
    #[doc(alias = "gtk_widget_is_toplevel")]
    fn is_toplevel(&self) -> bool {
        unsafe { from_glib(ffi::gtk_widget_is_toplevel(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)) }
    }

    /// This function should be called whenever keyboard navigation within
    /// a single widget hits a boundary. The function emits the
    /// [`keynav-failed`][struct@crate::Widget#keynav-failed] signal on the widget and its return
    /// value 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 handler returns [`false`] for
    /// [`DirectionType::TabForward`][crate::DirectionType::TabForward] and [`DirectionType::TabBackward`][crate::DirectionType::TabBackward]. 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 container(s).
    #[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(),
            ))
        }
    }

    /// Lists the closures used by `self` for accelerator group connections
    /// with [`AccelGroupExtManual::connect_accel_group_by_path()`][crate::prelude::AccelGroupExtManual::connect_accel_group_by_path()] or [`AccelGroupExtManual::connect_accel_group()`][crate::prelude::AccelGroupExtManual::connect_accel_group()].
    /// The closures can be used to monitor accelerator changes on `self`,
    /// by connecting to the [`AccelGroup`][crate::AccelGroup] signal of the
    /// [`AccelGroup`][crate::AccelGroup] of a closure which can be found out with
    /// [`AccelGroup::from_accel_closure()`][crate::AccelGroup::from_accel_closure()].
    ///
    /// # Returns
    ///
    ///
    ///  a newly allocated `GList` of closures
    #[doc(alias = "gtk_widget_list_accel_closures")]
    fn list_accel_closures(&self) -> Vec<glib::Closure> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_widget_list_accel_closures(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves a [`None`]-terminated array of strings containing the prefixes of
    /// [`gio::ActionGroup`][crate::gio::ActionGroup]'s available to `self`.
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array of strings.
    #[doc(alias = "gtk_widget_list_action_prefixes")]
    fn list_action_prefixes(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_widget_list_action_prefixes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns a newly allocated list of the widgets, normally labels, for
    /// which this widget is the target of a mnemonic (see for example,
    /// [`LabelExt::set_mnemonic_widget()`][crate::prelude::LabelExt::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; free this list
    ///  with `g_list_free()` when you are done with it.
    #[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,
            ))
        }
    }

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

    /// 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(),
            ))
        }
    }

    /// This function is only for use in widget implementations.
    ///
    /// Flags the widget for a rerun of the GtkWidgetClass::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()].
    #[doc(alias = "gtk_widget_queue_allocate")]
    fn queue_allocate(&self) {
        unsafe {
            ffi::gtk_widget_queue_allocate(self.as_ref().to_glib_none().0);
        }
    }

    /// Mark `self` as needing to recompute its expand flags. Call
    /// this function when setting legacy expand child properties
    /// on the child of a container.
    ///
    /// See [`compute_expand()`][Self::compute_expand()].
    #[doc(alias = "gtk_widget_queue_compute_expand")]
    fn queue_compute_expand(&self) {
        unsafe {
            ffi::gtk_widget_queue_compute_expand(self.as_ref().to_glib_none().0);
        }
    }

    /// Equivalent to calling [`queue_draw_area()`][Self::queue_draw_area()] for the
    /// entire area of a widget.
    #[doc(alias = "gtk_widget_queue_draw")]
    fn queue_draw(&self) {
        unsafe {
            ffi::gtk_widget_queue_draw(self.as_ref().to_glib_none().0);
        }
    }

    /// Convenience function that calls [`queue_draw_region()`][Self::queue_draw_region()] on
    /// the region created from the given coordinates.
    ///
    /// The region here is specified in widget coordinates.
    /// Widget coordinates are a bit odd; for historical reasons, they are
    /// defined as `self`->window coordinates for widgets that return [`true`] for
    /// [`has_window()`][Self::has_window()], and are relative to `self`->allocation.x,
    /// `self`->allocation.y otherwise.
    ///
    /// `width` or `height` may be 0, in this case this function does
    /// nothing. Negative values for `width` and `height` are not allowed.
    /// ## `x`
    /// x coordinate of upper-left corner of rectangle to redraw
    /// ## `y`
    /// y coordinate of upper-left corner of rectangle to redraw
    /// ## `width`
    /// width of region to draw
    /// ## `height`
    /// height of region to draw
    #[doc(alias = "gtk_widget_queue_draw_area")]
    fn queue_draw_area(&self, x: i32, y: i32, width: i32, height: i32) {
        unsafe {
            ffi::gtk_widget_queue_draw_area(self.as_ref().to_glib_none().0, x, y, width, height);
        }
    }

    /// Invalidates the area of `self` defined by `region` by calling
    /// [`Window::invalidate_region()`][crate::gdk::Window::invalidate_region()] on the widget’s window and all its
    /// child windows. Once the main loop becomes idle (after the current
    /// batch of events has been processed, roughly), the window will
    /// receive expose events for the union of all regions that have been
    /// invalidated.
    ///
    /// Normally you would only use this function in widget
    /// implementations. You might also use it to schedule a redraw of a
    /// [`DrawingArea`][crate::DrawingArea] or some portion thereof.
    /// ## `region`
    /// region to draw
    #[doc(alias = "gtk_widget_queue_draw_region")]
    fn queue_draw_region(&self, region: &cairo::Region) {
        unsafe {
            ffi::gtk_widget_queue_draw_region(
                self.as_ref().to_glib_none().0,
                region.to_glib_none().0,
            );
        }
    }

    /// This function is only for use in widget implementations.
    /// Flags a widget to have its size renegotiated; 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], [`Label`][crate::Label]
    /// queues a resize to ensure there’s enough space for the new text.
    ///
    /// Note that you cannot call [`queue_resize()`][Self::queue_resize()] on a widget
    /// from inside its implementation of the GtkWidgetClass::size_allocate
    /// virtual method. Calls to [`queue_resize()`][Self::queue_resize()] from inside
    /// GtkWidgetClass::size_allocate will be silently ignored.
    #[doc(alias = "gtk_widget_queue_resize")]
    fn queue_resize(&self) {
        unsafe {
            ffi::gtk_widget_queue_resize(self.as_ref().to_glib_none().0);
        }
    }

    /// This function works like [`queue_resize()`][Self::queue_resize()],
    /// except that the widget is not invalidated.
    #[doc(alias = "gtk_widget_queue_resize_no_redraw")]
    fn queue_resize_no_redraw(&self) {
        unsafe {
            ffi::gtk_widget_queue_resize_no_redraw(self.as_ref().to_glib_none().0);
        }
    }

    /// Creates the GDK (windowing system) resources associated with a
    /// widget. For example, `self`->window will be created when a widget
    /// is realized. 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
    /// [`realize()`][Self::realize()] 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
    /// [`draw`][struct@crate::Widget#draw]. Or simply g_signal_connect () to the
    /// [`realize`][struct@crate::Widget#realize] signal.
    #[doc(alias = "gtk_widget_realize")]
    fn realize(&self) {
        unsafe {
            ffi::gtk_widget_realize(self.as_ref().to_glib_none().0);
        }
    }

    /// Registers a [`gdk::Window`][crate::gdk::Window] with the widget and sets it up so that
    /// the widget receives events for it. Call [`unregister_window()`][Self::unregister_window()]
    /// when destroying the window.
    ///
    /// Before 3.8 you needed to call [`Window::set_user_data()`][crate::gdk::Window::set_user_data()] directly to set
    /// this up. This is now deprecated and you should use [`register_window()`][Self::register_window()]
    /// instead. Old code will keep working as is, although some new features like
    /// transparency might not work perfectly.
    /// ## `window`
    /// a [`gdk::Window`][crate::gdk::Window]
    #[doc(alias = "gtk_widget_register_window")]
    fn register_window(&self, window: &gdk::Window) {
        unsafe {
            ffi::gtk_widget_register_window(
                self.as_ref().to_glib_none().0,
                window.to_glib_none().0,
            );
        }
    }

    /// Removes an accelerator from `self`, previously installed with
    /// [`add_accelerator()`][Self::add_accelerator()].
    /// ## `accel_group`
    /// accel group for this widget
    /// ## `accel_key`
    /// GDK keyval of the accelerator
    /// ## `accel_mods`
    /// modifier key combination of the accelerator
    ///
    /// # Returns
    ///
    /// whether an accelerator was installed and could be removed
    #[doc(alias = "gtk_widget_remove_accelerator")]
    fn remove_accelerator(
        &self,
        accel_group: &impl IsA<AccelGroup>,
        accel_key: u32,
        accel_mods: gdk::ModifierType,
    ) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_remove_accelerator(
                self.as_ref().to_glib_none().0,
                accel_group.as_ref().to_glib_none().0,
                accel_key,
                accel_mods.into_glib(),
            ))
        }
    }

    /// 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`][crate::Widget] that was previously set as a mnemonic label for
    ///  `self` with [`add_mnemonic_label()`][Self::add_mnemonic_label()].
    #[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,
            );
        }
    }

    /// Updates the style context of `self` and all descendants
    /// by updating its widget path. `GtkContainers` may want
    /// to use this on a child when reordering it in a way that a different
    /// style might apply to it. See also [`ContainerExt::path_for_child()`][crate::prelude::ContainerExt::path_for_child()].
    #[doc(alias = "gtk_widget_reset_style")]
    fn reset_style(&self) {
        unsafe {
            ffi::gtk_widget_reset_style(self.as_ref().to_glib_none().0);
        }
    }

    /// Sends the focus change `event` to `self`
    ///
    /// This function is not meant to be used by applications. The only time it
    /// should be used is when it is necessary for a [`Widget`][crate::Widget] to assign focus
    /// to a widget that is semantically owned by the first widget even though
    /// it’s not a direct child - for instance, a search entry in a floating
    /// window similar to the quick search in [`TreeView`][crate::TreeView].
    ///
    /// An example of its usage is:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
    ///
    ///   fevent->focus_change.type = GDK_FOCUS_CHANGE;
    ///   fevent->focus_change.in = TRUE;
    ///   fevent->focus_change.window = _gtk_widget_get_window (widget);
    ///   if (fevent->focus_change.window != NULL)
    ///     g_object_ref (fevent->focus_change.window);
    ///
    ///   gtk_widget_send_focus_change (widget, fevent);
    ///
    ///   gdk_event_free (event);
    /// ```
    /// ## `event`
    /// a `GdkEvent` of type GDK_FOCUS_CHANGE
    ///
    /// # Returns
    ///
    /// the return value from the event signal emission: [`true`]
    ///  if the event was handled, and [`false`] otherwise
    #[doc(alias = "gtk_widget_send_focus_change")]
    fn send_focus_change(&self, event: &gdk::Event) -> bool {
        unsafe {
            from_glib(ffi::gtk_widget_send_focus_change(
                self.as_ref().to_glib_none().0,
                mut_override(event.to_glib_none().0),
            ))
        }
    }

    /// Given an accelerator group, `accel_group`, and an accelerator path,
    /// `accel_path`, sets up an accelerator in `accel_group` so whenever the
    /// key binding that is defined for `accel_path` is pressed, `self`
    /// will be activated. This removes any accelerators (for any
    /// accelerator group) installed by previous calls to
    /// [`set_accel_path()`][Self::set_accel_path()]. Associating accelerators with
    /// paths allows them to be modified by the user and the modifications
    /// to be saved for future use. (See `gtk_accel_map_save()`.)
    ///
    /// This function is a low level function that would most likely
    /// be used by a menu creation system like `GtkUIManager`. If you
    /// use `GtkUIManager`, setting up accelerator paths will be done
    /// automatically.
    ///
    /// Even when you you aren’t using `GtkUIManager`, if you only want to
    /// set up accelerators on menu items [`GtkMenuItemExt::set_accel_path()`][crate::prelude::GtkMenuItemExt::set_accel_path()]
    /// provides a somewhat more convenient interface.
    ///
    /// Note that `accel_path` string will be stored in a `GQuark`. Therefore, if you
    /// pass a static string, you can save some memory by interning it first with
    /// `g_intern_static_string()`.
    /// ## `accel_path`
    /// path used to look up the accelerator
    /// ## `accel_group`
    /// a [`AccelGroup`][crate::AccelGroup].
    #[doc(alias = "gtk_widget_set_accel_path")]
    fn set_accel_path(&self, accel_path: Option<&str>, accel_group: Option<&impl IsA<AccelGroup>>) {
        unsafe {
            ffi::gtk_widget_set_accel_path(
                self.as_ref().to_glib_none().0,
                accel_path.to_glib_none().0,
                accel_group.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the widget’s allocation. This should not be used
    /// directly, but from within a widget’s size_allocate method.
    ///
    /// The allocation set should be the “adjusted” or actual
    /// allocation. If you’re implementing a [`Container`][crate::Container], you want to use
    /// [`size_allocate()`][Self::size_allocate()] instead of [`set_allocation()`][Self::set_allocation()].
    /// The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
    /// allocation inside [`size_allocate()`][Self::size_allocate()] to create an adjusted
    /// allocation.
    /// ## `allocation`
    /// a pointer to a `GtkAllocation` to copy from
    #[doc(alias = "gtk_widget_set_allocation")]
    fn set_allocation(&self, allocation: &Allocation) {
        unsafe {
            ffi::gtk_widget_set_allocation(
                self.as_ref().to_glib_none().0,
                allocation.to_glib_none().0,
            );
        }
    }

    /// Sets whether the application intends to draw on the widget in
    /// an [`draw`][struct@crate::Widget#draw] handler.
    ///
    /// This is a hint to the widget and does not affect the behavior of
    /// the GTK+ core; many widgets ignore this flag entirely. For widgets
    /// that do pay attention to the flag, such as [`EventBox`][crate::EventBox] and [`Window`][crate::Window],
    /// the effect is to suppress default themed drawing of the widget's
    /// background. (Children of the widget will still be drawn.) The application
    /// is then entirely responsible for drawing the widget background.
    ///
    /// Note that the background is still drawn when the widget is mapped.
    /// ## `app_paintable`
    /// [`true`] if the application will paint on the widget
    #[doc(alias = "gtk_widget_set_app_paintable")]
    fn set_app_paintable(&self, app_paintable: bool) {
        unsafe {
            ffi::gtk_widget_set_app_paintable(
                self.as_ref().to_glib_none().0,
                app_paintable.into_glib(),
            );
        }
    }

    /// Specifies whether `self` can be a default widget. See
    /// [`grab_default()`][Self::grab_default()] for details about the meaning of
    /// “default”.
    /// ## `can_default`
    /// whether or not `self` can be a default widget.
    #[doc(alias = "gtk_widget_set_can_default")]
    fn set_can_default(&self, can_default: bool) {
        unsafe {
            ffi::gtk_widget_set_can_default(
                self.as_ref().to_glib_none().0,
                can_default.into_glib(),
            );
        }
    }

    /// Specifies whether `self` can own the input focus. See
    /// [`grab_focus()`][Self::grab_focus()] for actually setting the input focus on a
    /// widget.
    /// ## `can_focus`
    /// whether or not `self` can own the input focus.
    #[doc(alias = "gtk_widget_set_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 `self` should be mapped along with its when its parent
    /// is mapped and `self` has been shown with [`show()`][Self::show()].
    ///
    /// 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 container implementations and
    /// never should be called by an application.
    /// ## `is_visible`
    /// if [`true`], `self` should be mapped along with its parent.
    #[doc(alias = "gtk_widget_set_child_visible")]
    fn set_child_visible(&self, is_visible: bool) {
        unsafe {
            ffi::gtk_widget_set_child_visible(
                self.as_ref().to_glib_none().0,
                is_visible.into_glib(),
            );
        }
    }

    /// Sets the widget’s clip. This must not be used directly,
    /// but from within a widget’s size_allocate method.
    /// It must be called after [`set_allocation()`][Self::set_allocation()] (or after chaining up
    /// to the parent class), because that function resets the clip.
    ///
    /// The clip set should be the area that `self` draws on. If `self` is a
    /// [`Container`][crate::Container], the area must contain all children's clips.
    ///
    /// If this function is not called by `self` during a ::size-allocate handler,
    /// the clip will be set to `self`'s allocation.
    /// ## `clip`
    /// a pointer to a `GtkAllocation` to copy from
    #[doc(alias = "gtk_widget_set_clip")]
    fn set_clip(&self, clip: &Allocation) {
        unsafe {
            ffi::gtk_widget_set_clip(self.as_ref().to_glib_none().0, clip.to_glib_none().0);
        }
    }

    /// Enables or disables a [`gdk::Device`][crate::gdk::Device] to interact with `self`
    /// and all its children.
    ///
    /// It does so by descending through the [`gdk::Window`][crate::gdk::Window] hierarchy
    /// and enabling the same mask that is has for core events
    /// (i.e. the one that [`Window::events()`][crate::gdk::Window::events()] returns).
    /// ## `device`
    /// a [`gdk::Device`][crate::gdk::Device]
    /// ## `enabled`
    /// whether to enable the device
    #[doc(alias = "gtk_widget_set_device_enabled")]
    fn set_device_enabled(&self, device: &gdk::Device, enabled: bool) {
        unsafe {
            ffi::gtk_widget_set_device_enabled(
                self.as_ref().to_glib_none().0,
                device.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Sets the device event mask (see [`gdk::EventMask`][crate::gdk::EventMask]) for a widget. The event
    /// mask determines which events a widget will receive from `device`. Keep
    /// in mind that different widgets have different default event masks, and by
    /// changing the event mask you may disrupt a widget’s functionality,
    /// so be careful. This function must be called while a widget is
    /// unrealized. Consider [`add_device_events()`][Self::add_device_events()] for widgets that are
    /// already realized, or if you want to preserve the existing event
    /// mask. This function can’t be used with windowless widgets (which return
    /// [`false`] from [`has_window()`][Self::has_window()]);
    /// to get events on those widgets, place them inside a [`EventBox`][crate::EventBox]
    /// and receive events on the event box.
    /// ## `device`
    /// a [`gdk::Device`][crate::gdk::Device]
    /// ## `events`
    /// event mask
    #[doc(alias = "gtk_widget_set_device_events")]
    fn set_device_events(&self, device: &gdk::Device, events: gdk::EventMask) {
        unsafe {
            ffi::gtk_widget_set_device_events(
                self.as_ref().to_glib_none().0,
                device.to_glib_none().0,
                events.into_glib(),
            );
        }
    }

    /// Sets the reading direction on a particular 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 present, except for containers
    /// where the containers are arranged in an order that is explicitly
    /// visual rather than logical (such as buttons for text justification).
    ///
    /// If the direction is set to [`TextDirection::None`][crate::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());
        }
    }

    /// 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")]
    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 the font map to use for Pango rendering. When not set, the widget
    /// will inherit the font map from its parent.
    /// ## `font_map`
    /// a [`pango::FontMap`][crate::pango::FontMap], or [`None`] to unset any previously
    ///  set font map
    #[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 Pango rendering in this widget.
    /// When not set, the default font options for the [`gdk::Screen`][crate::gdk::Screen] will be used.
    /// ## `options`
    /// a [`cairo::FontOptions`][crate::cairo::FontOptions], or [`None`] to unset any
    ///  previously set default font options.
    #[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 `self`.
    /// See the [`halign`][struct@crate::Widget#halign] property.
    /// ## `align`
    /// the horizontal alignment
    #[doc(alias = "gtk_widget_set_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 `self` to `has_tooltip`. See
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] for more information.
    /// ## `has_tooltip`
    /// whether or not `self` has a tooltip.
    #[doc(alias = "gtk_widget_set_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(),
            );
        }
    }

    /// Specifies whether `self` has a [`gdk::Window`][crate::gdk::Window] of its own. Note that
    /// all realized widgets have a non-[`None`] “window” pointer
    /// ([`window()`][Self::window()] never returns a [`None`] window when a widget
    /// is realized), but for many of them it’s actually the [`gdk::Window`][crate::gdk::Window] of
    /// one of its parent widgets. Widgets that do not create a `window` for
    /// themselves in [`realize`][struct@crate::Widget#realize] must announce this by
    /// calling this function with `has_window` = [`false`].
    ///
    /// This function should only be called by widget implementations,
    /// and they should call it in their `init()` function.
    /// ## `has_window`
    /// whether or not `self` has a window.
    #[doc(alias = "gtk_widget_set_has_window")]
    fn set_has_window(&self, has_window: bool) {
        unsafe {
            ffi::gtk_widget_set_has_window(self.as_ref().to_glib_none().0, has_window.into_glib());
        }
    }

    /// Sets whether the widget would like any available extra horizontal
    /// space. When a user resizes a [`Window`][crate::Window], widgets with expand=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
    /// container can decide how the expandability of children affects the
    /// expansion of the container 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")]
    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 (see [`hexpands()`][Self::hexpands()]) will
    /// be used.
    ///
    /// The 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")]
    fn set_hexpand_set(&self, set: bool) {
        unsafe {
            ffi::gtk_widget_set_hexpand_set(self.as_ref().to_glib_none().0, set.into_glib());
        }
    }

    /// Marks the widget as being mapped.
    ///
    /// This function should only ever be called in a derived widget's
    /// “map” or “unmap” implementation.
    /// ## `mapped`
    /// [`true`] to mark the widget as mapped
    #[doc(alias = "gtk_widget_set_mapped")]
    fn set_mapped(&self, mapped: bool) {
        unsafe {
            ffi::gtk_widget_set_mapped(self.as_ref().to_glib_none().0, mapped.into_glib());
        }
    }

    /// Sets the bottom margin of `self`.
    /// See the [`margin-bottom`][struct@crate::Widget#margin-bottom] property.
    /// ## `margin`
    /// the bottom margin
    #[doc(alias = "gtk_widget_set_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 `self`.
    /// See the [`margin-end`][struct@crate::Widget#margin-end] property.
    /// ## `margin`
    /// the end margin
    #[doc(alias = "gtk_widget_set_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 `self`.
    /// See the [`margin-start`][struct@crate::Widget#margin-start] property.
    /// ## `margin`
    /// the start margin
    #[doc(alias = "gtk_widget_set_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 `self`.
    /// See the [`margin-top`][struct@crate::Widget#margin-top] property.
    /// ## `margin`
    /// the top margin
    #[doc(alias = "gtk_widget_set_margin_top")]
    fn set_margin_top(&self, margin: i32) {
        unsafe {
            ffi::gtk_widget_set_margin_top(self.as_ref().to_glib_none().0, margin);
        }
    }

    /// Widgets can be named, which allows you to refer to them 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")]
    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);
        }
    }

    /// Sets the [`no-show-all`][struct@crate::Widget#no-show-all] property, which determines whether
    /// calls to [`show_all()`][Self::show_all()] will affect this widget.
    ///
    /// This is mostly for use in constructing widget hierarchies with externally
    /// controlled visibility, see `GtkUIManager`.
    /// ## `no_show_all`
    /// the new value for the “no-show-all” property
    #[doc(alias = "gtk_widget_set_no_show_all")]
    fn set_no_show_all(&self, no_show_all: bool) {
        unsafe {
            ffi::gtk_widget_set_no_show_all(
                self.as_ref().to_glib_none().0,
                no_show_all.into_glib(),
            );
        }
    }

    /// Request the `self` to be rendered partially transparent,
    /// with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
    /// are clamped to the [0,1] range.).
    /// This works on both toplevel widget, and child widgets, although there
    /// are some limitations:
    ///
    /// For toplevel widgets this depends on the capabilities of the windowing
    /// system. On X11 this has any effect only on X screens with a compositing manager
    /// running. See `gtk_widget_is_composited()`. On Windows it should work
    /// always, although setting a window’s opacity after the window has been
    /// shown causes it to flicker once on Windows.
    ///
    /// For child widgets it doesn’t work if any affected widget has a native window, or
    /// disables double buffering.
    /// ## `opacity`
    /// desired opacity, between 0 and 1
    #[doc(alias = "gtk_widget_set_opacity")]
    fn set_opacity(&self, opacity: f64) {
        unsafe {
            ffi::gtk_widget_set_opacity(self.as_ref().to_glib_none().0, opacity);
        }
    }

    /// This function is useful only when implementing subclasses of
    /// [`Container`][crate::Container].
    /// Sets the container as the parent of `self`, and takes care of
    /// some details such as updating the state and style of the child
    /// to reflect its new location. The opposite function is
    /// [`unparent()`][Self::unparent()].
    /// ## `parent`
    /// parent container
    #[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 a non default parent window for `self`.
    ///
    /// For [`Window`][crate::Window] classes, setting a `parent_window` effects whether
    /// the window is a toplevel window or can be embedded into other
    /// widgets.
    ///
    /// For [`Window`][crate::Window] classes, this needs to be called before the
    /// window is realized.
    /// ## `parent_window`
    /// the new parent window.
    #[doc(alias = "gtk_widget_set_parent_window")]
    fn set_parent_window(&self, parent_window: &gdk::Window) {
        unsafe {
            ffi::gtk_widget_set_parent_window(
                self.as_ref().to_glib_none().0,
                parent_window.to_glib_none().0,
            );
        }
    }

    /// Marks the widget as being realized. This function must only be
    /// called after all `GdkWindows` for the `self` have been created
    /// and registered.
    ///
    /// This function should only ever be called in a derived widget's
    /// “realize” or “unrealize” implementation.
    /// ## `realized`
    /// [`true`] to mark the widget as realized
    #[doc(alias = "gtk_widget_set_realized")]
    fn set_realized(&self, realized: bool) {
        unsafe {
            ffi::gtk_widget_set_realized(self.as_ref().to_glib_none().0, realized.into_glib());
        }
    }

    /// Specifies whether `self` will be treated as the default widget
    /// within its toplevel when it has the focus, even if another widget
    /// is the default.
    ///
    /// See [`grab_default()`][Self::grab_default()] for details about the meaning of
    /// “default”.
    /// ## `receives_default`
    /// whether or not `self` can be a default widget.
    #[doc(alias = "gtk_widget_set_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 whether the entire widget is queued for drawing when its size
    /// allocation changes. By default, this setting is [`true`] and
    /// the entire widget is redrawn on every size change. If your widget
    /// leaves the upper left unchanged when made bigger, turning this
    /// setting off will improve performance.
    ///
    /// Note that for widgets where [`has_window()`][Self::has_window()] is [`false`]
    /// setting this flag to [`false`] turns off all allocation on resizing:
    /// the widget will not even redraw if its position changes; this is to
    /// allow containers that don’t draw anything to avoid excess
    /// invalidations. If you set this flag on a widget with no window that
    /// does draw on `self`->window, you are
    /// responsible for invalidating both the old and new allocation of the
    /// widget when the widget is moved and responsible for invalidating
    /// regions newly when the widget increases size.
    /// ## `redraw_on_allocate`
    /// if [`true`], the entire widget will be redrawn
    ///  when it is allocated to a new size. Otherwise, only the
    ///  new portion of the widget will be redrawn.
    #[doc(alias = "gtk_widget_set_redraw_on_allocate")]
    fn set_redraw_on_allocate(&self, redraw_on_allocate: bool) {
        unsafe {
            ffi::gtk_widget_set_redraw_on_allocate(
                self.as_ref().to_glib_none().0,
                redraw_on_allocate.into_glib(),
            );
        }
    }

    /// Sets the sensitivity of a 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")]
    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 a 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. When dealing with window sizes,
    /// [`GtkWindowExt::set_geometry_hints()`][crate::prelude::GtkWindowExt::set_geometry_hints()] can be a useful function as well.
    ///
    /// 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's
    /// basically impossible to hardcode a size that will always be
    /// correct.
    ///
    /// 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
    /// [`Widget`][crate::Widget] properties margin-left, margin-right, margin-top, and
    /// 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);
        }
    }

    /// This function is for use in widget implementations. Turns on flag
    /// values in the current widget state (insensitive, prelighted, etc.).
    ///
    /// This function accepts the values [`StateFlags::DIR_LTR`][crate::StateFlags::DIR_LTR] and
    /// [`StateFlags::DIR_RTL`][crate::StateFlags::DIR_RTL] but ignores them. If you want to set the widget's
    /// direction, use [`set_direction()`][Self::set_direction()].
    ///
    /// It is worth mentioning that any other state than [`StateFlags::INSENSITIVE`][crate::StateFlags::INSENSITIVE],
    /// will be propagated down to all non-internal children if `self` is a
    /// [`Container`][crate::Container], while [`StateFlags::INSENSITIVE`][crate::StateFlags::INSENSITIVE] itself will be propagated
    /// down to all [`Container`][crate::Container] children by different means than turning on the
    /// state flag down the hierarchy, both [`state_flags()`][Self::state_flags()] and
    /// [`is_sensitive()`][Self::is_sensitive()] will make use of these.
    /// ## `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(),
            );
        }
    }

    /// Enables or disables multiple pointer awareness. If this setting is [`true`],
    /// `self` will start receiving multiple, per device enter/leave events. Note
    /// that if custom `GdkWindows` are created in [`realize`][struct@crate::Widget#realize],
    /// [`Window::set_support_multidevice()`][crate::gdk::Window::set_support_multidevice()] will have to be called manually on them.
    /// ## `support_multidevice`
    /// [`true`] to support input from multiple devices.
    #[doc(alias = "gtk_widget_set_support_multidevice")]
    fn set_support_multidevice(&self, support_multidevice: bool) {
        unsafe {
            ffi::gtk_widget_set_support_multidevice(
                self.as_ref().to_glib_none().0,
                support_multidevice.into_glib(),
            );
        }
    }

    /// Sets `markup` as the contents of the tooltip, which is marked up with
    ///  the [Pango text markup language][PangoMarkupFormat].
    ///
    /// This function will take care of setting [`has-tooltip`][struct@crate::Widget#has-tooltip] to [`true`]
    /// and of the default handler for the [`query-tooltip`][struct@crate::Widget#query-tooltip] signal.
    ///
    /// See also the [`tooltip-markup`][struct@crate::Widget#tooltip-markup] property and
    /// [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    /// ## `markup`
    /// the contents of the tooltip for `self`, or [`None`]
    #[doc(alias = "gtk_widget_set_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 `text` as the contents of the tooltip. This function will take
    /// care of setting [`has-tooltip`][struct@crate::Widget#has-tooltip] to [`true`] and of the default
    /// handler for the [`query-tooltip`][struct@crate::Widget#query-tooltip] signal.
    ///
    /// See also the [`tooltip-text`][struct@crate::Widget#tooltip-text] property and [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    /// ## `text`
    /// the contents of the tooltip for `self`
    #[doc(alias = "gtk_widget_set_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);
        }
    }

    /// Replaces the default window used for displaying
    /// tooltips with `custom_window`. GTK+ will take care of showing and
    /// hiding `custom_window` at the right moment, to behave likewise as
    /// the default tooltip window. If `custom_window` is [`None`], the default
    /// tooltip window will be used.
    /// ## `custom_window`
    /// a [`Window`][crate::Window], or [`None`]
    #[doc(alias = "gtk_widget_set_tooltip_window")]
    fn set_tooltip_window(&self, custom_window: Option<&impl IsA<Window>>) {
        unsafe {
            ffi::gtk_widget_set_tooltip_window(
                self.as_ref().to_glib_none().0,
                custom_window.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the vertical alignment of `self`.
    /// See the [`valign`][struct@crate::Widget#valign] property.
    /// ## `align`
    /// the vertical alignment
    #[doc(alias = "gtk_widget_set_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")]
    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 (see [`vexpands()`][Self::vexpands()]) 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")]
    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()].
    ///
    /// This function simply calls [`show()`][Self::show()] or [`hide()`][Self::hide()]
    /// but is nicer to use when the visibility of the widget depends on
    /// some condition.
    /// ## `visible`
    /// whether the widget should be shown or not
    #[doc(alias = "gtk_widget_set_visible")]
    fn set_visible(&self, visible: bool) {
        unsafe {
            ffi::gtk_widget_set_visible(self.as_ref().to_glib_none().0, visible.into_glib());
        }
    }

    /// Sets the visual that should be used for by widget and its children for
    /// creating `GdkWindows`. The visual must be on the same [`gdk::Screen`][crate::gdk::Screen] as
    /// returned by [`screen()`][Self::screen()], so handling the
    /// [`screen-changed`][struct@crate::Widget#screen-changed] signal is necessary.
    ///
    /// Setting a new `visual` will not cause `self` to recreate its windows,
    /// so you should call this function before `self` is realized.
    /// ## `visual`
    /// visual to be used or [`None`] to unset a previous one
    #[doc(alias = "gtk_widget_set_visual")]
    fn set_visual(&self, visual: Option<&gdk::Visual>) {
        unsafe {
            ffi::gtk_widget_set_visual(self.as_ref().to_glib_none().0, visual.to_glib_none().0);
        }
    }

    /// Sets a widget’s window. This function should only be used in a
    /// widget’s [`realize`][struct@crate::Widget#realize] implementation. The `window` passed is
    /// usually either new window created with [`gdk::Window::new()`][crate::gdk::Window::new()], or the
    /// window of its parent widget as returned by
    /// [`parent_window()`][Self::parent_window()].
    ///
    /// Widgets must indicate whether they will create their own [`gdk::Window`][crate::gdk::Window]
    /// by calling [`set_has_window()`][Self::set_has_window()]. This is usually done in the
    /// widget’s `init()` function.
    ///
    /// Note that this function does not add any reference to `window`.
    /// ## `window`
    /// a [`gdk::Window`][crate::gdk::Window]
    #[doc(alias = "gtk_widget_set_window")]
    fn set_window(&self, window: gdk::Window) {
        unsafe {
            ffi::gtk_widget_set_window(self.as_ref().to_glib_none().0, window.into_glib_ptr());
        }
    }

    /// Sets a shape for this widget’s GDK window. This allows for
    /// transparent windows etc., see [`Window::shape_combine_region()`][crate::gdk::Window::shape_combine_region()]
    /// for more information.
    /// ## `region`
    /// shape to be added, or [`None`] to remove an existing shape
    #[doc(alias = "gtk_widget_shape_combine_region")]
    fn shape_combine_region(&self, region: Option<&cairo::Region>) {
        unsafe {
            ffi::gtk_widget_shape_combine_region(
                self.as_ref().to_glib_none().0,
                mut_override(region.to_glib_none().0),
            );
        }
    }

    /// Flags a widget to be displayed. Any widget that isn’t shown will
    /// not appear on the screen. If you want to show all the widgets in a
    /// container, it’s easier to call [`show_all()`][Self::show_all()] on the
    /// container, instead of individually showing the widgets.
    ///
    /// 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 container is shown, it is immediately realized and
    /// mapped; other shown widgets are realized and mapped when their
    /// toplevel container is realized and mapped.
    #[doc(alias = "gtk_widget_show")]
    fn show(&self) {
        unsafe {
            ffi::gtk_widget_show(self.as_ref().to_glib_none().0);
        }
    }

    /// Recursively shows a widget, and any child widgets (if the widget is
    /// a container).
    #[doc(alias = "gtk_widget_show_all")]
    fn show_all(&self) {
        unsafe {
            ffi::gtk_widget_show_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Shows a widget. If the widget is an unmapped toplevel widget
    /// (i.e. a [`Window`][crate::Window] that has not yet been shown), enter the main
    /// loop and wait for the window to actually be mapped. Be careful;
    /// because the main loop is running, anything can happen during
    /// this function.
    #[doc(alias = "gtk_widget_show_now")]
    fn show_now(&self) {
        unsafe {
            ffi::gtk_widget_show_now(self.as_ref().to_glib_none().0);
        }
    }

    /// This function is only used by [`Container`][crate::Container] subclasses, to assign a size
    /// and position to their child widgets.
    ///
    /// In this function, the allocation may be adjusted. It will be forced
    /// to a 1x1 minimum size, and the adjust_size_allocation virtual
    /// method on the child will be used to adjust the allocation. Standard
    /// adjustments include removing the widget’s margins, and applying the
    /// widget’s [`halign`][struct@crate::Widget#halign] and [`valign`][struct@crate::Widget#valign] properties.
    ///
    /// For baseline support in containers you need to use [`size_allocate_with_baseline()`][Self::size_allocate_with_baseline()]
    /// instead.
    /// ## `allocation`
    /// position and size to be allocated to `self`
    #[doc(alias = "gtk_widget_size_allocate")]
    fn size_allocate(&self, allocation: &Allocation) {
        unsafe {
            ffi::gtk_widget_size_allocate(
                self.as_ref().to_glib_none().0,
                mut_override(allocation.to_glib_none().0),
            );
        }
    }

    /// This function is only used by [`Container`][crate::Container] subclasses, to assign a size,
    /// position and (optionally) baseline to their child widgets.
    ///
    /// In this function, the allocation and baseline may be adjusted. It
    /// will be forced to a 1x1 minimum size, and the
    /// adjust_size_allocation virtual and adjust_baseline_allocation
    /// methods on the child will be used to adjust the allocation and
    /// baseline. Standard adjustments include removing the widget's
    /// margins, and applying the widget’s [`halign`][struct@crate::Widget#halign] and
    /// [`valign`][struct@crate::Widget#valign] properties.
    ///
    /// If the child widget does not have a valign of [`Align::Baseline`][crate::Align::Baseline] the
    /// baseline argument is ignored and -1 is used instead.
    /// ## `allocation`
    /// position and size to be allocated to `self`
    /// ## `baseline`
    /// The baseline of the child, or -1
    #[doc(alias = "gtk_widget_size_allocate_with_baseline")]
    fn size_allocate_with_baseline(&self, allocation: &mut Allocation, baseline: i32) {
        unsafe {
            ffi::gtk_widget_size_allocate_with_baseline(
                self.as_ref().to_glib_none().0,
                allocation.to_glib_none_mut().0,
                baseline,
            );
        }
    }

    //#[doc(alias = "gtk_widget_style_get")]
    //fn style_get(&self, first_property_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:gtk_widget_style_get() }
    //}

    /// Gets the value of a style property of `self`.
    /// ## `property_name`
    /// the name of a style property
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// location to return the property value
    #[doc(alias = "gtk_widget_style_get_property")]
    fn style_get_property(&self, property_name: &str) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::gtk_widget_style_get_property(
                self.as_ref().to_glib_none().0,
                property_name.to_glib_none().0,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    //#[doc(alias = "gtk_widget_style_get_valist")]
    //fn style_get_valist(&self, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi:gtk_widget_style_get_valist() }
    //}

    /// Reverts the effect of a previous call to [`freeze_child_notify()`][Self::freeze_child_notify()].
    /// This causes all queued [`child-notify`][struct@crate::Widget#child-notify] signals on `self` to be
    /// emitted.
    #[doc(alias = "gtk_widget_thaw_child_notify")]
    fn thaw_child_notify(&self) {
        unsafe {
            ffi::gtk_widget_thaw_child_notify(self.as_ref().to_glib_none().0);
        }
    }

    /// Translate coordinates relative to `self`’s allocation to coordinates
    /// relative to `dest_widget`’s allocations. In order to perform this
    /// operation, both widgets must be realized, and must share a common
    /// toplevel.
    /// ## `dest_widget`
    /// a [`Widget`][crate::Widget]
    /// ## `src_x`
    /// X position relative to `self`
    /// ## `src_y`
    /// Y position relative to `self`
    ///
    /// # Returns
    ///
    /// [`false`] if either widget was not realized, or there
    ///  was no common ancestor. In this case, nothing is stored in
    ///  *`dest_x` and *`dest_y`. Otherwise [`true`].
    ///
    /// ## `dest_x`
    /// location to store X position relative to `dest_widget`
    ///
    /// ## `dest_y`
    /// location to store Y position relative to `dest_widget`
    #[doc(alias = "gtk_widget_translate_coordinates")]
    fn translate_coordinates(
        &self,
        dest_widget: &impl IsA<Widget>,
        src_x: i32,
        src_y: i32,
    ) -> Option<(i32, i32)> {
        unsafe {
            let mut dest_x = mem::MaybeUninit::uninit();
            let mut dest_y = 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 where the toplevel of `self`
    /// is located. See [`Tooltip::trigger_tooltip_query()`][crate::Tooltip::trigger_tooltip_query()] for more
    /// information.
    #[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);
        }
    }

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

    /// This function is only for use in widget implementations.
    /// Should be called by implementations of the remove method
    /// on [`Container`][crate::Container], to dissociate a child from the container.
    #[doc(alias = "gtk_widget_unparent")]
    fn unparent(&self) {
        unsafe {
            ffi::gtk_widget_unparent(self.as_ref().to_glib_none().0);
        }
    }

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

    /// Unregisters a [`gdk::Window`][crate::gdk::Window] from the widget that was previously set up with
    /// [`register_window()`][Self::register_window()]. You need to call this when the window is
    /// no longer used by the widget, such as when you destroy it.
    /// ## `window`
    /// a [`gdk::Window`][crate::gdk::Window]
    #[doc(alias = "gtk_widget_unregister_window")]
    fn unregister_window(&self, window: &gdk::Window) {
        unsafe {
            ffi::gtk_widget_unregister_window(
                self.as_ref().to_glib_none().0,
                window.to_glib_none().0,
            );
        }
    }

    /// This function is for use in widget implementations. Turns off flag
    /// values for the current widget state (insensitive, prelighted, etc.).
    /// See [`set_state_flags()`][Self::set_state_flags()].
    /// ## `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());
        }
    }

    #[doc(alias = "composite-child")]
    fn is_composite_child(&self) -> bool {
        ObjectExt::property(self.as_ref(), "composite-child")
    }

    /// Whether to expand in both directions. Setting this sets both [`hexpand`][struct@crate::Widget#hexpand] and [`vexpand`][struct@crate::Widget#vexpand]
    fn expands(&self) -> bool {
        ObjectExt::property(self.as_ref(), "expand")
    }

    /// Whether to expand in both directions. Setting this sets both [`hexpand`][struct@crate::Widget#hexpand] and [`vexpand`][struct@crate::Widget#vexpand]
    fn set_expand(&self, expand: bool) {
        ObjectExt::set_property(self.as_ref(), "expand", expand)
    }

    #[doc(alias = "has-default")]
    fn set_has_default(&self, has_default: bool) {
        ObjectExt::set_property(self.as_ref(), "has-default", has_default)
    }

    #[doc(alias = "has-focus")]
    fn set_has_focus(&self, has_focus: bool) {
        ObjectExt::set_property(self.as_ref(), "has-focus", has_focus)
    }

    #[doc(alias = "height-request")]
    fn height_request(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "height-request")
    }

    #[doc(alias = "height-request")]
    fn set_height_request(&self, height_request: i32) {
        ObjectExt::set_property(self.as_ref(), "height-request", height_request)
    }

    #[doc(alias = "is-focus")]
    fn set_is_focus(&self, is_focus: bool) {
        ObjectExt::set_property(self.as_ref(), "is-focus", is_focus)
    }

    /// Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    fn margin(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "margin")
    }

    /// Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    fn set_margin(&self, margin: i32) {
        ObjectExt::set_property(self.as_ref(), "margin", margin)
    }

    #[doc(alias = "width-request")]
    fn width_request(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "width-request")
    }

    #[doc(alias = "width-request")]
    fn set_width_request(&self, width_request: i32) {
        ObjectExt::set_property(self.as_ref(), "width-request", width_request)
    }

    #[doc(alias = "accel-closures-changed")]
    fn connect_accel_closures_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn accel_closures_changed_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"accel-closures-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    accel_closures_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::button-press-event signal will be emitted when a button
    /// (typically from a mouse) is pressed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the
    /// widget needs to enable the [`gdk::EventMask::BUTTON_PRESS_MASK`][crate::gdk::EventMask::BUTTON_PRESS_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventButton`][crate::gdk::EventButton] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "button-press-event")]
    fn connect_button_press_event<
        F: Fn(&Self, &gdk::EventButton) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn button_press_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventButton) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventButton,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"button-press-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    button_press_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::button-release-event signal will be emitted when a button
    /// (typically from a mouse) is released.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the
    /// widget needs to enable the [`gdk::EventMask::BUTTON_RELEASE_MASK`][crate::gdk::EventMask::BUTTON_RELEASE_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventButton`][crate::gdk::EventButton] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "button-release-event")]
    fn connect_button_release_event<
        F: Fn(&Self, &gdk::EventButton) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn button_release_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventButton) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventButton,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"button-release-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    button_release_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Determines whether an accelerator that activates the signal
    /// identified by `signal_id` can currently be activated.
    /// This signal is present to allow applications and derived
    /// widgets to override the default [`Widget`][crate::Widget] handling
    /// for determining whether an accelerator can be activated.
    /// ## `signal_id`
    /// the ID of a signal installed on `widget`
    ///
    /// # Returns
    ///
    /// [`true`] if the signal can be activated.
    #[doc(alias = "can-activate-accel")]
    fn connect_can_activate_accel<F: Fn(&Self, u32) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn can_activate_accel_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, u32) -> bool + 'static,
        >(
            this: *mut ffi::GtkWidget,
            signal_id: libc::c_uint,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(Widget::from_glib_borrow(this).unsafe_cast_ref(), signal_id).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"can-activate-accel\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    can_activate_accel_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::child-notify signal is emitted for each
    /// [child property][child-properties] that has
    /// changed on an object. The signal's detail holds the property name.
    /// ## `child_property`
    /// the [`glib::ParamSpec`][crate::glib::ParamSpec] of the changed child property
    #[doc(alias = "child-notify")]
    fn connect_child_notify<F: Fn(&Self, &glib::ParamSpec) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn child_notify_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &glib::ParamSpec) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            child_property: *mut glib::gobject_ffi::GParamSpec,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(child_property),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("child-notify::{name}\0"));
            let signal_name: &[u8] = detailed_signal_name
                .as_ref()
                .map_or(&b"child-notify\0"[..], |n| n.as_bytes());
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    child_notify_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::configure-event signal will be emitted when the size, position or
    /// stacking of the `widget`'s window has changed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    /// ## `event`
    /// the [`gdk::EventConfigure`][crate::gdk::EventConfigure] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "configure-event")]
    fn connect_configure_event<F: Fn(&Self, &gdk::EventConfigure) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn configure_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventConfigure) -> bool + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventConfigure,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"configure-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    configure_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a redirected window belonging to `widget` gets drawn into.
    /// The region/area members of the event shows what area of the redirected
    /// drawable was drawn into.
    /// ## `event`
    /// the [`gdk::EventExpose`][crate::gdk::EventExpose] event
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "damage-event")]
    fn connect_damage_event<F: Fn(&Self, &gdk::EventExpose) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn damage_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventExpose) -> bool + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventExpose,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"damage-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    damage_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::delete-event signal is emitted if a user requests that
    /// a toplevel window is closed. The default handler for this signal
    /// destroys the window. Connecting [`WidgetExtManual::hide_on_delete()`][crate::prelude::WidgetExtManual::hide_on_delete()] to
    /// this signal will cause the window to be hidden instead, so that
    /// it can later be shown again without reconstructing it.
    /// ## `event`
    /// the event which triggered this signal
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "delete-event")]
    fn connect_delete_event<F: Fn(&Self, &gdk::Event) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn delete_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::Event) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEvent,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_none(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"delete-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    delete_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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,
        ) {
            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 _,
                b"destroy\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    destroy_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::destroy-event signal is emitted when a [`gdk::Window`][crate::gdk::Window] is destroyed.
    /// You rarely get this signal, because most widgets disconnect themselves
    /// from their window before they destroy it, so no widget owns the
    /// window at destroy time.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    /// ## `event`
    /// the event which triggered this signal
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "destroy-event")]
    fn connect_destroy_event<F: Fn(&Self, &gdk::Event) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn destroy_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::Event) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEvent,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_none(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"destroy-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    destroy_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::direction-changed signal is emitted when the text direction
    /// of a widget changes.
    /// ## `previous_direction`
    /// the previous text direction of `widget`
    #[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,
        ) {
            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 _,
                b"direction-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    direction_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-begin signal is emitted on the drag source when a drag is
    /// started. A typical reason to connect to this signal is to set up a
    /// custom drag icon with e.g. [`drag_source_set_icon_pixbuf()`][Self::drag_source_set_icon_pixbuf()].
    ///
    /// Note that some widgets set up a drag icon in the default handler of
    /// this signal, so you may have to use `g_signal_connect_after()` to
    /// override what the default handler did.
    /// ## `context`
    /// the drag context
    #[doc(alias = "drag-begin")]
    fn connect_drag_begin<F: Fn(&Self, &gdk::DragContext) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_begin_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-begin\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_begin_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-data-delete signal is emitted on the drag source when a drag
    /// with the action [`gdk::DragAction::MOVE`][crate::gdk::DragAction::MOVE] is successfully completed. The signal
    /// handler is responsible for deleting the data that has been dropped. What
    /// "delete" means depends on the context of the drag operation.
    /// ## `context`
    /// the drag context
    #[doc(alias = "drag-data-delete")]
    fn connect_drag_data_delete<F: Fn(&Self, &gdk::DragContext) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_data_delete_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-data-delete\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_data_delete_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-data-get signal is emitted on the drag source when the drop
    /// site requests the data which is dragged. It is the responsibility of
    /// the signal handler to fill `data` with the data in the format which
    /// is indicated by `info`. See [`SelectionData::set()`][crate::SelectionData::set()] and
    /// [`SelectionData::set_text()`][crate::SelectionData::set_text()].
    /// ## `context`
    /// the drag context
    /// ## `data`
    /// the [`SelectionData`][crate::SelectionData] to be filled with the dragged data
    /// ## `info`
    /// the info that has been registered with the target in the
    ///  [`TargetList`][crate::TargetList]
    /// ## `time`
    /// the timestamp at which the data was requested
    #[doc(alias = "drag-data-get")]
    fn connect_drag_data_get<
        F: Fn(&Self, &gdk::DragContext, &SelectionData, u32, u32) + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_data_get_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext, &SelectionData, u32, u32) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            data: *mut ffi::GtkSelectionData,
            info: libc::c_uint,
            time: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                &from_glib_borrow(data),
                info,
                time,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-data-get\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_data_get_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-data-received signal is emitted on the drop site when the
    /// dragged data has been received. If the data was received in order to
    /// determine whether the drop will be accepted, the handler is expected
    /// to call `gdk_drag_status()` and not finish the drag.
    /// If the data was received in response to a [`drag-drop`][struct@crate::Widget#drag-drop] signal
    /// (and this is the last target to be received), the handler for this
    /// signal is expected to process the received data and then call
    /// `gtk_drag_finish()`, setting the `success` parameter depending on
    /// whether the data was processed successfully.
    ///
    /// Applications must create some means to determine why the signal was emitted
    /// and therefore whether to call `gdk_drag_status()` or `gtk_drag_finish()`.
    ///
    /// The handler may inspect the selected action with
    /// [`DragContext::selected_action()`][crate::gdk::DragContext::selected_action()] before calling
    /// `gtk_drag_finish()`, e.g. to implement [`gdk::DragAction::ASK`][crate::gdk::DragAction::ASK] as
    /// shown in the following example:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// void
    /// drag_data_received (GtkWidget          *widget,
    ///                     GdkDragContext     *context,
    ///                     gint                x,
    ///                     gint                y,
    ///                     GtkSelectionData   *data,
    ///                     guint               info,
    ///                     guint               time)
    /// {
    ///   if ((data->length >= 0) && (data->format == 8))
    ///     {
    ///       GdkDragAction action;
    ///
    ///       // handle data here
    ///
    ///       action = gdk_drag_context_get_selected_action (context);
    ///       if (action == GDK_ACTION_ASK)
    ///         {
    ///           GtkWidget *dialog;
    ///           gint response;
    ///
    ///           dialog = gtk_message_dialog_new (NULL,
    ///                                            GTK_DIALOG_MODAL |
    ///                                            GTK_DIALOG_DESTROY_WITH_PARENT,
    ///                                            GTK_MESSAGE_INFO,
    ///                                            GTK_BUTTONS_YES_NO,
    ///                                            "Move the data ?\n");
    ///           response = gtk_dialog_run (GTK_DIALOG (dialog));
    ///           gtk_widget_destroy (dialog);
    ///
    ///           if (response == GTK_RESPONSE_YES)
    ///             action = GDK_ACTION_MOVE;
    ///           else
    ///             action = GDK_ACTION_COPY;
    ///          }
    ///
    ///       gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time);
    ///     }
    ///   else
    ///     gtk_drag_finish (context, FALSE, FALSE, time);
    ///  }
    /// ```
    /// ## `context`
    /// the drag context
    /// ## `x`
    /// where the drop happened
    /// ## `y`
    /// where the drop happened
    /// ## `data`
    /// the received data
    /// ## `info`
    /// the info that has been registered with the target in the
    ///  [`TargetList`][crate::TargetList]
    /// ## `time`
    /// the timestamp at which the data was received
    #[doc(alias = "drag-data-received")]
    fn connect_drag_data_received<
        F: Fn(&Self, &gdk::DragContext, i32, i32, &SelectionData, u32, u32) + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_data_received_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext, i32, i32, &SelectionData, u32, u32) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            x: libc::c_int,
            y: libc::c_int,
            data: *mut ffi::GtkSelectionData,
            info: libc::c_uint,
            time: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                x,
                y,
                &from_glib_borrow(data),
                info,
                time,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-data-received\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_data_received_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-drop signal is emitted on the drop site when the user drops
    /// the data onto the widget. The signal handler must determine whether
    /// the cursor position is in a drop zone or not. If it is not in a drop
    /// zone, it returns [`false`] and no further processing is necessary.
    /// Otherwise, the handler returns [`true`]. In this case, the handler must
    /// ensure that `gtk_drag_finish()` is called to let the source know that
    /// the drop is done. The call to `gtk_drag_finish()` can be done either
    /// directly or in a [`drag-data-received`][struct@crate::Widget#drag-data-received] handler which gets
    /// triggered by calling [`drag_get_data()`][Self::drag_get_data()] to receive the data for one
    /// or more of the supported targets.
    /// ## `context`
    /// the drag context
    /// ## `x`
    /// the x coordinate of the current cursor position
    /// ## `y`
    /// the y coordinate of the current cursor position
    /// ## `time`
    /// the timestamp of the motion event
    ///
    /// # Returns
    ///
    /// whether the cursor position is in a drop zone
    #[doc(alias = "drag-drop")]
    fn connect_drag_drop<F: Fn(&Self, &gdk::DragContext, i32, i32, u32) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_drop_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext, i32, i32, u32) -> bool + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            x: libc::c_int,
            y: libc::c_int,
            time: libc::c_uint,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                x,
                y,
                time,
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-drop\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_drop_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-end signal is emitted on the drag source when a drag is
    /// finished. A typical reason to connect to this signal is to undo
    /// things done in [`drag-begin`][struct@crate::Widget#drag-begin].
    /// ## `context`
    /// the drag context
    #[doc(alias = "drag-end")]
    fn connect_drag_end<F: Fn(&Self, &gdk::DragContext) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn drag_end_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-end\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_end_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-failed signal is emitted on the drag source when a drag has
    /// failed. The signal handler may hook custom code to handle a failed DnD
    /// operation based on the type of error, it returns [`true`] is the failure has
    /// been already handled (not showing the default "drag operation failed"
    /// animation), otherwise it returns [`false`].
    /// ## `context`
    /// the drag context
    /// ## `result`
    /// the result of the drag operation
    ///
    /// # Returns
    ///
    /// [`true`] if the failed drag operation has been already handled.
    #[doc(alias = "drag-failed")]
    fn connect_drag_failed<
        F: Fn(&Self, &gdk::DragContext, DragResult) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_failed_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext, DragResult) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            result: ffi::GtkDragResult,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                from_glib(result),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-failed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_failed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-leave signal is emitted on the drop site when the cursor
    /// leaves the widget. A typical reason to connect to this signal is to
    /// undo things done in [`drag-motion`][struct@crate::Widget#drag-motion], e.g. undo highlighting
    /// with [`drag_unhighlight()`][Self::drag_unhighlight()].
    ///
    ///
    /// Likewise, the [`drag-leave`][struct@crate::Widget#drag-leave] signal is also emitted before the
    /// ::drag-drop signal, for instance to allow cleaning up of a preview item
    /// created in the [`drag-motion`][struct@crate::Widget#drag-motion] signal handler.
    /// ## `context`
    /// the drag context
    /// ## `time`
    /// the timestamp of the motion event
    #[doc(alias = "drag-leave")]
    fn connect_drag_leave<F: Fn(&Self, &gdk::DragContext, u32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_leave_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext, u32) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            time: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                time,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-leave\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_leave_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::drag-motion signal is emitted on the drop site when the user
    /// moves the cursor over the widget during a drag. The signal handler
    /// must determine whether the cursor position is in a drop zone or not.
    /// If it is not in a drop zone, it returns [`false`] and no further processing
    /// is necessary. Otherwise, the handler returns [`true`]. In this case, the
    /// handler is responsible for providing the necessary information for
    /// displaying feedback to the user, by calling `gdk_drag_status()`.
    ///
    /// If the decision whether the drop will be accepted or rejected can't be
    /// made based solely on the cursor position and the type of the data, the
    /// handler may inspect the dragged data by calling [`drag_get_data()`][Self::drag_get_data()] and
    /// defer the `gdk_drag_status()` call to the [`drag-data-received`][struct@crate::Widget#drag-data-received]
    /// handler. Note that you must pass [`DestDefaults::DROP`][crate::DestDefaults::DROP],
    /// [`DestDefaults::MOTION`][crate::DestDefaults::MOTION] or [`DestDefaults::ALL`][crate::DestDefaults::ALL] to [`WidgetExtManual::drag_dest_set()`][crate::prelude::WidgetExtManual::drag_dest_set()]
    /// when using the drag-motion signal that way.
    ///
    /// Also note that there is no drag-enter signal. The drag receiver has to
    /// keep track of whether he has received any drag-motion signals since the
    /// last [`drag-leave`][struct@crate::Widget#drag-leave] and if not, treat the drag-motion signal as
    /// an "enter" signal. Upon an "enter", the handler will typically highlight
    /// the drop site with [`drag_highlight()`][Self::drag_highlight()].
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// drag_motion (GtkWidget      *widget,
    ///              GdkDragContext *context,
    ///              gint            x,
    ///              gint            y,
    ///              guint           time)
    /// {
    ///   GdkAtom target;
    ///
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (!private_data->drag_highlight)
    ///    {
    ///      private_data->drag_highlight = 1;
    ///      gtk_drag_highlight (widget);
    ///    }
    ///
    ///   target = gtk_drag_dest_find_target (widget, context, NULL);
    ///   if (target == GDK_NONE)
    ///     gdk_drag_status (context, 0, time);
    ///   else
    ///    {
    ///      private_data->pending_status
    ///         = gdk_drag_context_get_suggested_action (context);
    ///      gtk_drag_get_data (widget, context, target, time);
    ///    }
    ///
    ///   return TRUE;
    /// }
    ///
    /// static void
    /// drag_data_received (GtkWidget        *widget,
    ///                     GdkDragContext   *context,
    ///                     gint              x,
    ///                     gint              y,
    ///                     GtkSelectionData *selection_data,
    ///                     guint             info,
    ///                     guint             time)
    /// {
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (private_data->suggested_action)
    ///    {
    ///      private_data->suggested_action = 0;
    ///
    ///      // We are getting this data due to a request in drag_motion,
    ///      // rather than due to a request in drag_drop, so we are just
    ///      // supposed to call gdk_drag_status(), not actually paste in
    ///      // the data.
    ///
    ///      str = gtk_selection_data_get_text (selection_data);
    ///      if (!data_is_acceptable (str))
    ///        gdk_drag_status (context, 0, time);
    ///      else
    ///        gdk_drag_status (context,
    ///                         private_data->suggested_action,
    ///                         time);
    ///    }
    ///   else
    ///    {
    ///      // accept the drop
    ///    }
    /// }
    /// ```
    /// ## `context`
    /// the drag context
    /// ## `x`
    /// the x coordinate of the current cursor position
    /// ## `y`
    /// the y coordinate of the current cursor position
    /// ## `time`
    /// the timestamp of the motion event
    ///
    /// # Returns
    ///
    /// whether the cursor position is in a drop zone
    #[doc(alias = "drag-motion")]
    fn connect_drag_motion<F: Fn(&Self, &gdk::DragContext, i32, i32, u32) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_motion_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::DragContext, i32, i32, u32) -> bool + 'static,
        >(
            this: *mut ffi::GtkWidget,
            context: *mut gdk::ffi::GdkDragContext,
            x: libc::c_int,
            y: libc::c_int,
            time: libc::c_uint,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(context),
                x,
                y,
                time,
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"drag-motion\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    drag_motion_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when a widget is supposed to render itself.
    /// The `widget`'s top left corner must be painted at the origin of
    /// the passed in context and be sized to the values returned by
    /// [`allocated_width()`][Self::allocated_width()] and
    /// [`allocated_height()`][Self::allocated_height()].
    ///
    /// Signal handlers connected to this signal can modify the cairo
    /// context passed as `cr` in any way they like and don't need to
    /// restore it. The signal emission takes care of calling `cairo_save()`
    /// before and `cairo_restore()` after invoking the handler.
    ///
    /// The signal handler will get a `cr` with a clip region already set to the
    /// widget's dirty region, i.e. to the area that needs repainting. Complicated
    /// widgets that want to avoid redrawing themselves completely can get the full
    /// extents of the clip region with `gdk_cairo_get_clip_rectangle()`, or they can
    /// get a finer-grained representation of the dirty region with
    /// `cairo_copy_clip_rectangle_list()`.
    /// ## `cr`
    /// the cairo context to draw to
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    /// [`false`] to propagate the event further.
    #[doc(alias = "draw")]
    fn connect_draw<F: Fn(&Self, &cairo::Context) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn draw_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &cairo::Context) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            cr: *mut cairo::ffi::cairo_t,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(cr),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"draw\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    draw_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::enter-notify-event will be emitted when the pointer enters
    /// the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::ENTER_NOTIFY_MASK`][crate::gdk::EventMask::ENTER_NOTIFY_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventCrossing`][crate::gdk::EventCrossing] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "enter-notify-event")]
    fn connect_enter_notify_event<
        F: Fn(&Self, &gdk::EventCrossing) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn enter_notify_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventCrossing) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventCrossing,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"enter-notify-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    enter_notify_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The GTK+ main loop will emit three signals for each GDK event delivered
    /// to a widget: one generic ::event signal, another, more specific,
    /// signal that matches the type of event delivered (e.g.
    /// [`key-press-event`][struct@crate::Widget#key-press-event]) and finally a generic
    /// [`event-after`][struct@crate::Widget#event-after] signal.
    /// ## `event`
    /// the `GdkEvent` which triggered this signal
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event
    /// and to cancel the emission of the second specific ::event signal.
    ///  [`false`] to propagate the event further and to allow the emission of
    ///  the second signal. The ::event-after signal is emitted regardless of
    ///  the return value.
    #[doc(alias = "event")]
    fn connect_event<F: Fn(&Self, &gdk::Event) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::Event) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEvent,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_none(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// After the emission of the [`event`][struct@crate::Widget#event] signal and (optionally)
    /// the second more specific signal, ::event-after will be emitted
    /// regardless of the previous two signals handlers return values.
    /// ## `event`
    /// the `GdkEvent` which triggered this signal
    #[doc(alias = "event-after")]
    fn connect_event_after<F: Fn(&Self, &gdk::Event) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn event_after_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::Event) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEvent,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_none(event),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"event-after\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    event_after_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event. [`false`] to propagate the event further.
    #[doc(alias = "focus")]
    fn connect_focus<F: Fn(&Self, DirectionType) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn focus_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 {
            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 _,
                b"focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::focus-in-event signal will be emitted when the keyboard focus
    /// enters the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::FOCUS_CHANGE_MASK`][crate::gdk::EventMask::FOCUS_CHANGE_MASK] mask.
    /// ## `event`
    /// the [`gdk::EventFocus`][crate::gdk::EventFocus] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "focus-in-event")]
    fn connect_focus_in_event<F: Fn(&Self, &gdk::EventFocus) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn focus_in_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventFocus) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventFocus,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"focus-in-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    focus_in_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::focus-out-event signal will be emitted when the keyboard focus
    /// leaves the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::FOCUS_CHANGE_MASK`][crate::gdk::EventMask::FOCUS_CHANGE_MASK] mask.
    /// ## `event`
    /// the [`gdk::EventFocus`][crate::gdk::EventFocus] which triggered this
    ///  signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "focus-out-event")]
    fn connect_focus_out_event<F: Fn(&Self, &gdk::EventFocus) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn focus_out_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventFocus) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventFocus,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"focus-out-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    focus_out_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a pointer or keyboard grab on a window belonging
    /// to `widget` gets broken.
    ///
    /// On X11, this happens when the grab window becomes unviewable
    /// (i.e. it or one of its ancestors is unmapped), or if the same
    /// application grabs the pointer or keyboard again.
    /// ## `event`
    /// the [`gdk::EventGrabBroken`][crate::gdk::EventGrabBroken] event
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for
    ///  the event. [`false`] to propagate the event further.
    #[doc(alias = "grab-broken-event")]
    fn connect_grab_broken_event<
        F: Fn(&Self, &gdk::EventGrabBroken) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn grab_broken_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventGrabBroken) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventGrabBroken,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"grab-broken-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    grab_broken_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "grab-focus")]
    fn connect_grab_focus<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn grab_focus_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"grab-focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    grab_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_grab_focus(&self) {
        self.emit_by_name::<()>("grab-focus", &[]);
    }

    /// The ::grab-notify signal is emitted when a widget becomes
    /// shadowed by a GTK+ grab (not a pointer or keyboard grab) on
    /// another widget, or when it becomes unshadowed due to a grab
    /// being removed.
    ///
    /// A widget is shadowed by a [`grab_add()`][Self::grab_add()] when the topmost
    /// grab widget in the grab stack of its window group is not
    /// its ancestor.
    /// ## `was_grabbed`
    /// [`false`] if the widget becomes shadowed, [`true`]
    ///  if it becomes unshadowed
    #[doc(alias = "grab-notify")]
    fn connect_grab_notify<F: Fn(&Self, bool) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn grab_notify_trampoline<P: IsA<Widget>, F: Fn(&P, bool) + 'static>(
            this: *mut ffi::GtkWidget,
            was_grabbed: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(was_grabbed),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"grab-notify\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    grab_notify_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::hide signal is emitted when `widget` is hidden, for example with
    /// [`hide()`][Self::hide()].
    #[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,
        ) {
            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 _,
                b"hide\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    hide_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::hierarchy-changed signal is emitted when the
    /// anchored state of a widget changes. A widget is
    /// “anchored” when its toplevel
    /// ancestor is a [`Window`][crate::Window]. This signal is emitted when
    /// a widget changes from un-anchored to anchored or vice-versa.
    /// ## `previous_toplevel`
    /// the previous toplevel ancestor, or [`None`]
    ///  if the widget was previously unanchored
    #[doc(alias = "hierarchy-changed")]
    fn connect_hierarchy_changed<F: Fn(&Self, Option<&Widget>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn hierarchy_changed_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, Option<&Widget>) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            previous_toplevel: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<Widget>::from_glib_borrow(previous_toplevel)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"hierarchy-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    hierarchy_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::key-press-event signal is emitted when a key is pressed. The signal
    /// emission will reoccur at the key-repeat rate when the key is kept pressed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::KEY_PRESS_MASK`][crate::gdk::EventMask::KEY_PRESS_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventKey`][crate::gdk::EventKey] which triggered this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "key-press-event")]
    fn connect_key_press_event<F: Fn(&Self, &gdk::EventKey) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn key_press_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventKey) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventKey,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"key-press-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    key_press_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::key-release-event signal is emitted when a key is released.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::KEY_RELEASE_MASK`][crate::gdk::EventMask::KEY_RELEASE_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventKey`][crate::gdk::EventKey] which triggered this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "key-release-event")]
    fn connect_key_release_event<F: Fn(&Self, &gdk::EventKey) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn key_release_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventKey) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventKey,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"key-release-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    key_release_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Gets 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 container(s).
    #[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 {
            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 _,
                b"keynav-failed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    keynav_failed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::leave-notify-event will be emitted when the pointer leaves
    /// the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::LEAVE_NOTIFY_MASK`][crate::gdk::EventMask::LEAVE_NOTIFY_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventCrossing`][crate::gdk::EventCrossing] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "leave-notify-event")]
    fn connect_leave_notify_event<
        F: Fn(&Self, &gdk::EventCrossing) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn leave_notify_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventCrossing) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventCrossing,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"leave-notify-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    leave_notify_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::map signal is emitted when `widget` is going to be mapped, that is
    /// when the widget is visible (which is controlled with
    /// [`set_visible()`][Self::set_visible()]) and all its parents up to the toplevel widget
    /// are also visible. Once the map has occurred, [`map-event`][struct@crate::Widget#map-event] will
    /// be emitted.
    ///
    /// 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,
        ) {
            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 _,
                b"map\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    map_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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 {
            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 _,
                b"mnemonic-activate\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    mnemonic_activate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::motion-notify-event signal is emitted when the pointer moves
    /// over the widget's [`gdk::Window`][crate::gdk::Window].
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget
    /// needs to enable the [`gdk::EventMask::POINTER_MOTION_MASK`][crate::gdk::EventMask::POINTER_MOTION_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventMotion`][crate::gdk::EventMotion] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "motion-notify-event")]
    fn connect_motion_notify_event<
        F: Fn(&Self, &gdk::EventMotion) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn motion_notify_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventMotion) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventMotion,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"motion-notify-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    motion_notify_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[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,
        ) {
            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 _,
                b"move-focus\0".as_ptr() as *const _,
                Some(transmute::<_, 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]);
    }

    /// The ::parent-set signal is emitted when a new parent
    /// has been set on a widget.
    /// ## `old_parent`
    /// the previous parent, or [`None`] if the widget
    ///  just got its initial parent.
    #[doc(alias = "parent-set")]
    fn connect_parent_set<F: Fn(&Self, Option<&Widget>) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn parent_set_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, Option<&Widget>) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            old_parent: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<Widget>::from_glib_borrow(old_parent)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"parent-set\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    parent_set_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal gets emitted whenever a widget should pop up a context
    /// menu. This usually happens through the standard key binding mechanism;
    /// by pressing a certain key while a widget is focused, the user can cause
    /// the widget to pop up a menu. For example, the [`Entry`][crate::Entry] widget creates
    /// a menu with clipboard commands. See the
    /// [Popup Menu Migration Checklist][checklist-popup-menu]
    /// for an example of how to use this signal.
    ///
    /// # Returns
    ///
    /// [`true`] if a menu was activated
    #[doc(alias = "popup-menu")]
    fn connect_popup_menu<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn popup_menu_trampoline<P: IsA<Widget>, F: Fn(&P) -> bool + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(Widget::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"popup-menu\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    popup_menu_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_popup_menu(&self) -> bool {
        self.emit_by_name("popup-menu", &[])
    }

    /// The ::property-notify-event signal will be emitted when a property on
    /// the `widget`'s window has been changed or deleted.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROPERTY_CHANGE_MASK`][crate::gdk::EventMask::PROPERTY_CHANGE_MASK] mask.
    /// ## `event`
    /// the [`gdk::EventProperty`][crate::gdk::EventProperty] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "property-notify-event")]
    fn connect_property_notify_event<
        F: Fn(&Self, &gdk::EventProperty) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn property_notify_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventProperty) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventProperty,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"property-notify-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    property_notify_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROXIMITY_IN_MASK`][crate::gdk::EventMask::PROXIMITY_IN_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventProximity`][crate::gdk::EventProximity] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "proximity-in-event")]
    fn connect_proximity_in_event<
        F: Fn(&Self, &gdk::EventProximity) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn proximity_in_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventProximity) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventProximity,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"proximity-in-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    proximity_in_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROXIMITY_OUT_MASK`][crate::gdk::EventMask::PROXIMITY_OUT_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventProximity`][crate::gdk::EventProximity] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "proximity-out-event")]
    fn connect_proximity_out_event<
        F: Fn(&Self, &gdk::EventProximity) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn proximity_out_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventProximity) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventProximity,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"proximity-out-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    proximity_out_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when [`has-tooltip`][struct@crate::Widget#has-tooltip] 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 where the request has
    ///  been emitted, relative to `widget`'s left side
    /// ## `y`
    /// the y coordinate of the cursor position where the request has
    ///  been emitted, relative to `widget`'s top
    /// ## `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: libc::c_int,
            y: libc::c_int,
            keyboard_mode: glib::ffi::gboolean,
            tooltip: *mut ffi::GtkTooltip,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            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 _,
                b"query-tooltip\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    query_tooltip_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::realize signal is emitted when `widget` is associated with a
    /// [`gdk::Window`][crate::gdk::Window], which 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,
        ) {
            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 _,
                b"realize\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    realize_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::screen-changed signal gets emitted when the
    /// screen of a widget has changed.
    /// ## `previous_screen`
    /// the previous screen, or [`None`] if the
    ///  widget was not associated with a screen before
    #[doc(alias = "screen-changed")]
    fn connect_screen_changed<F: Fn(&Self, Option<&gdk::Screen>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn screen_changed_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, Option<&gdk::Screen>) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            previous_screen: *mut gdk::ffi::GdkScreen,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<gdk::Screen>::from_glib_borrow(previous_screen)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"screen-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    screen_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::scroll-event signal is emitted when a button in the 4 to 7
    /// range is pressed. Wheel mice are usually configured to generate
    /// button press events for buttons 4 and 5 when the wheel is turned.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::SCROLL_MASK`][crate::gdk::EventMask::SCROLL_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    /// ## `event`
    /// the [`gdk::EventScroll`][crate::gdk::EventScroll] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "scroll-event")]
    fn connect_scroll_event<F: Fn(&Self, &gdk::EventScroll) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn scroll_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventScroll) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventScroll,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"scroll-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    scroll_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::selection-clear-event signal will be emitted when the
    /// the `widget`'s window has lost ownership of a selection.
    /// ## `event`
    /// the [`gdk::EventSelection`][crate::gdk::EventSelection] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "selection-clear-event")]
    fn connect_selection_clear_event<
        F: Fn(&Self, &gdk::EventSelection) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn selection_clear_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventSelection) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventSelection,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"selection-clear-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    selection_clear_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "selection-get")]
    fn connect_selection_get<F: Fn(&Self, &SelectionData, u32, u32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn selection_get_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &SelectionData, u32, u32) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            data: *mut ffi::GtkSelectionData,
            info: libc::c_uint,
            time: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(data),
                info,
                time,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"selection-get\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    selection_get_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event. [`false`] to propagate the event further.
    #[doc(alias = "selection-notify-event")]
    fn connect_selection_notify_event<
        F: Fn(&Self, &gdk::EventSelection) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn selection_notify_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventSelection) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventSelection,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"selection-notify-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    selection_notify_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "selection-received")]
    fn connect_selection_received<F: Fn(&Self, &SelectionData, u32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn selection_received_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &SelectionData, u32) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            data: *mut ffi::GtkSelectionData,
            time: libc::c_uint,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(data),
                time,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"selection-received\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    selection_received_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::selection-request-event signal will be emitted when
    /// another client requests ownership of the selection owned by
    /// the `widget`'s window.
    /// ## `event`
    /// the [`gdk::EventSelection`][crate::gdk::EventSelection] which triggered
    ///  this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///  [`false`] to propagate the event further.
    #[doc(alias = "selection-request-event")]
    fn connect_selection_request_event<
        F: Fn(&Self, &gdk::EventSelection) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn selection_request_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventSelection) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventSelection,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"selection-request-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    selection_request_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::show signal is emitted when `widget` is shown, for example with
    /// [`show()`][Self::show()].
    #[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,
        ) {
            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 _,
                b"show\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    show_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    /// [`false`] to propagate the event further.
    #[doc(alias = "show-help")]
    fn connect_show_help<F: Fn(&Self, WidgetHelpType) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn show_help_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, WidgetHelpType) -> bool + 'static,
        >(
            this: *mut ffi::GtkWidget,
            help_type: ffi::GtkWidgetHelpType,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(help_type),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"show-help\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    show_help_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_show_help(&self, help_type: WidgetHelpType) -> bool {
        self.emit_by_name("show-help", &[&help_type])
    }

    /// ## `allocation`
    /// the region which has been
    ///  allocated to the widget.
    #[doc(alias = "size-allocate")]
    fn connect_size_allocate<F: Fn(&Self, &Allocation) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn size_allocate_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &Allocation) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            allocation: *mut ffi::GtkAllocation,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_none(allocation),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"size-allocate\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    size_allocate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::state-flags-changed signal is 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,
        ) {
            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 _,
                b"state-flags-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    state_flags_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::style-updated signal is a convenience signal that is emitted when the
    /// [`changed`][struct@crate::StyleContext#changed] signal is emitted on the `widget`'s associated
    /// [`StyleContext`][crate::StyleContext] as returned by [`style_context()`][Self::style_context()].
    ///
    /// Note that style-modifying functions like `gtk_widget_override_color()` also
    /// cause this signal to be emitted.
    #[doc(alias = "style-updated")]
    fn connect_style_updated<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn style_updated_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"style-updated\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    style_updated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "touch-event")]
    fn connect_touch_event<F: Fn(&Self, &gdk::Event) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn touch_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::Event) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            object: *mut gdk::ffi::GdkEvent,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_none(object),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"touch-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    touch_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::unmap signal is emitted when `widget` is going to be unmapped, which
    /// means that 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,
        ) {
            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 _,
                b"unmap\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    unmap_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::unrealize signal is emitted when the [`gdk::Window`][crate::gdk::Window] associated with
    /// `widget` is destroyed, which 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,
        ) {
            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 _,
                b"unrealize\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    unrealize_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::window-state-event will be emitted when the state of the
    /// toplevel window associated to the `widget` changes.
    ///
    /// To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget
    /// needs to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable
    /// this mask automatically for all new windows.
    /// ## `event`
    /// the [`gdk::EventWindowState`][crate::gdk::EventWindowState] which
    ///  triggered this signal.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the
    ///  event. [`false`] to propagate the event further.
    #[doc(alias = "window-state-event")]
    fn connect_window_state_event<
        F: Fn(&Self, &gdk::EventWindowState) -> glib::Propagation + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn window_state_event_trampoline<
            P: IsA<Widget>,
            F: Fn(&P, &gdk::EventWindowState) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkWidget,
            event: *mut gdk::ffi::GdkEventWindowState,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Widget::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(event),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"window-state-event\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    window_state_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "app-paintable")]
    fn connect_app_paintable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_app_paintable_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::app-paintable\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_app_paintable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "can-default")]
    fn connect_can_default_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_default_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::can-default\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_can_default_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,
        ) {
            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 _,
                b"notify::can-focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_can_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "composite-child")]
    fn connect_composite_child_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_composite_child_trampoline<
            P: IsA<Widget>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::composite-child\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_composite_child_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "events")]
    fn connect_events_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_events_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::events\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_events_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "expand")]
    fn connect_expand_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_expand_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::expand\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_expand_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,
        ) {
            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 _,
                b"notify::focus-on-click\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_focus_on_click_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,
        ) {
            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 _,
                b"notify::halign\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::has-default\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::has-focus\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::has-tooltip\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::height-request\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::hexpand\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::hexpand-set\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_hexpand_set_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-focus")]
    fn connect_is_focus_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_focus_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::is-focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_is_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "margin")]
    fn connect_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_margin_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::margin\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_margin_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,
        ) {
            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 _,
                b"notify::margin-bottom\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::margin-end\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::margin-start\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::margin-top\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::name\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "no-show-all")]
    fn connect_no_show_all_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_no_show_all_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::no-show-all\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_no_show_all_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,
        ) {
            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 _,
                b"notify::opacity\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_opacity_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,
        ) {
            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 _,
                b"notify::parent\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::receives-default\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_receives_default_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,
        ) {
            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 _,
                b"notify::scale-factor\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::sensitive\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::tooltip-markup\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::tooltip-text\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::valign\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::vexpand\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::vexpand-set\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::visible\0".as_ptr() as *const _,
                Some(transmute::<_, 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,
        ) {
            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 _,
                b"notify::width-request\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_width_request_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "window")]
    fn connect_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_window_trampoline<P: IsA<Widget>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWidget,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::window\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_window_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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