gtk/auto/

label.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::{Align, Buildable, Container, Justification, Menu, Misc, MovementStep, Widget, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// The [`Label`][crate::Label] widget displays a small amount of text. As the name
    /// implies, most labels are used to label another widget such as a
    /// [`Button`][crate::Button], a [`MenuItem`][crate::MenuItem], or a [`ComboBox`][crate::ComboBox].
    ///
    /// # CSS nodes
    ///
    ///
    ///
    /// **⚠️ The following code is in plain ⚠️**
    ///
    /// ```plain
    /// label
    /// ├── [selection]
    /// ├── [link]
    /// ┊
    /// ╰── [link]
    /// ```
    ///
    /// GtkLabel has a single CSS node with the name label. A wide variety
    /// of style classes may be applied to labels, such as .title, .subtitle,
    /// .dim-label, etc. In the [`ShortcutsWindow`][crate::ShortcutsWindow], labels are used wth the
    /// .keycap style class.
    ///
    /// If the label has a selection, it gets a subnode with name selection.
    ///
    /// If the label has links, there is one subnode per link. These subnodes
    /// carry the link or visited state depending on whether they have been
    /// visited.
    ///
    /// # GtkLabel as GtkBuildable
    ///
    /// The GtkLabel implementation of the GtkBuildable interface supports a
    /// custom ``<attributes>`` element, which supports any number of ``<attribute>``
    /// elements. The ``<attribute>`` element has attributes named “name“, “value“,
    /// “start“ and “end“ and allows you to specify `PangoAttribute` values for
    /// this label.
    ///
    /// An example of a UI definition fragment specifying Pango attributes:
    ///
    ///
    ///
    /// **⚠️ The following code is in xml ⚠️**
    ///
    /// ```xml
    /// <object class="GtkLabel">
    ///   <attributes>
    ///     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
    ///     <attribute name="background" value="red" start="5" end="10"/>
    ///   </attributes>
    /// </object>
    /// ```
    ///
    /// The start and end attributes specify the range of characters to which the
    /// Pango attribute applies. If start and end are not specified, the attribute is
    /// applied to the whole text. Note that specifying ranges does not make much
    /// sense with translatable attributes. Use markup embedded in the translatable
    /// content instead.
    ///
    /// # Mnemonics
    ///
    /// Labels may contain “mnemonics”. Mnemonics are
    /// underlined characters in the label, used for keyboard navigation.
    /// Mnemonics are created by providing a string with an underscore before
    /// the mnemonic character, such as `"_File"`, to the
    /// functions [`with_mnemonic()`][Self::with_mnemonic()] or
    /// [`LabelExt::set_text_with_mnemonic()`][crate::prelude::LabelExt::set_text_with_mnemonic()].
    ///
    /// Mnemonics automatically activate any activatable widget the label is
    /// inside, such as a [`Button`][crate::Button]; if the label is not inside the
    /// mnemonic’s target widget, you have to tell the label about the target
    /// using [`LabelExt::set_mnemonic_widget()`][crate::prelude::LabelExt::set_mnemonic_widget()]. Here’s a simple example where
    /// the label is inside a button:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   // Pressing Alt+H will activate this button
    ///   GtkWidget *button = gtk_button_new ();
    ///   GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
    ///   gtk_container_add (GTK_CONTAINER (button), label);
    /// ```
    ///
    /// There’s a convenience function to create buttons with a mnemonic label
    /// already inside:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   // Pressing Alt+H will activate this button
    ///   GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");
    /// ```
    ///
    /// To create a mnemonic for a widget alongside the label, such as a
    /// [`Entry`][crate::Entry], you have to point the label at the entry with
    /// [`LabelExt::set_mnemonic_widget()`][crate::prelude::LabelExt::set_mnemonic_widget()]:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   // Pressing Alt+H will focus the entry
    ///   GtkWidget *entry = gtk_entry_new ();
    ///   GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
    ///   gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
    /// ```
    ///
    /// # Markup (styled text)
    ///
    /// To make it easy to format text in a label (changing colors,
    /// fonts, etc.), label text can be provided in a simple
    /// [markup format][PangoMarkupFormat].
    ///
    /// Here’s how to create a label with a small font:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   GtkWidget *label = gtk_label_new (NULL);
    ///   gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");
    /// ```
    ///
    /// (See [complete documentation][PangoMarkupFormat] of available
    /// tags in the Pango manual.)
    ///
    /// The markup passed to [`LabelExt::set_markup()`][crate::prelude::LabelExt::set_markup()] must be valid; for example,
    /// literal <, > and & characters must be escaped as &lt;, &gt;, and &amp;.
    /// If you pass text obtained from the user, file, or a network to
    /// [`LabelExt::set_markup()`][crate::prelude::LabelExt::set_markup()], you’ll want to escape it with
    /// `g_markup_escape_text()` or `g_markup_printf_escaped()`.
    ///
    /// Markup strings are just a convenient way to set the [`pango::AttrList`][crate::pango::AttrList] on
    /// a label; [`LabelExt::set_attributes()`][crate::prelude::LabelExt::set_attributes()] may be a simpler way to set
    /// attributes in some cases. Be careful though; [`pango::AttrList`][crate::pango::AttrList] tends to
    /// cause internationalization problems, unless you’re applying attributes
    /// to the entire string (i.e. unless you set the range of each attribute
    /// to [0, `G_MAXINT`)). The reason is that specifying the start_index and
    /// end_index for a `PangoAttribute` requires knowledge of the exact string
    /// being displayed, so translations will cause problems.
    ///
    /// # Selectable labels
    ///
    /// Labels can be made selectable with [`LabelExt::set_selectable()`][crate::prelude::LabelExt::set_selectable()].
    /// Selectable labels allow the user to copy the label contents to
    /// the clipboard. Only labels that contain useful-to-copy information
    /// — such as error messages — should be made selectable.
    ///
    /// # Text layout # {`label`-text-layout}
    ///
    /// A label can contain any number of paragraphs, but will have
    /// performance problems if it contains more than a small number.
    /// Paragraphs are separated by newlines or other paragraph separators
    /// understood by Pango.
    ///
    /// Labels can automatically wrap text if you call
    /// [`LabelExt::set_line_wrap()`][crate::prelude::LabelExt::set_line_wrap()].
    ///
    /// [`LabelExt::set_justify()`][crate::prelude::LabelExt::set_justify()] sets how the lines in a label align
    /// with one another. If you want to set how the label as a whole
    /// aligns in its available space, see the [`halign`][struct@crate::Widget#halign] and
    /// [`valign`][struct@crate::Widget#valign] properties.
    ///
    /// The [`width-chars`][struct@crate::Label#width-chars] and [`max-width-chars`][struct@crate::Label#max-width-chars] properties
    /// can be used to control the size allocation of ellipsized or wrapped
    /// labels. For ellipsizing labels, if either is specified (and less
    /// than the actual text size), it is used as the minimum width, and the actual
    /// text size is used as the natural width of the label. For wrapping labels,
    /// width-chars is used as the minimum width, if specified, and max-width-chars
    /// is used as the natural width. Even if max-width-chars specified, wrapping
    /// labels will be rewrapped to use all of the available width.
    ///
    /// Note that the interpretation of [`width-chars`][struct@crate::Label#width-chars] and
    /// [`max-width-chars`][struct@crate::Label#max-width-chars] has changed a bit with the introduction of
    /// [width-for-height geometry management.][geometry-management]
    ///
    /// # Links
    ///
    /// Since 2.18, GTK+ supports markup for clickable hyperlinks in addition
    /// to regular Pango markup. The markup for links is borrowed from HTML,
    /// using the ``<a>`` with “href“ and “title“ attributes. GTK+ renders links
    /// similar to the way they appear in web browsers, with colored, underlined
    /// text. The “title“ attribute is displayed as a tooltip on the link.
    ///
    /// An example looks like this:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// const gchar *text =
    /// "Go to the"
    /// "<a href=\"http://www.gtk.org title=\"&lt;i&gt;Our&lt;/i&gt; website\">"
    /// "GTK+ website</a> for more...";
    /// GtkWidget *label = gtk_label_new (NULL);
    /// gtk_label_set_markup (GTK_LABEL (label), text);
    /// ```
    ///
    /// It is possible to implement custom handling for links and their tooltips with
    /// the [`activate-link`][struct@crate::Label#activate-link] signal and the [`LabelExt::current_uri()`][crate::prelude::LabelExt::current_uri()] function.
    ///
    /// ## Properties
    ///
    ///
    /// #### `angle`
    ///  The angle that the baseline of the label makes with the horizontal,
    /// in degrees, measured counterclockwise. An angle of 90 reads from
    /// from bottom to top, an angle of 270, from top to bottom. Ignored
    /// if the label is selectable.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `attributes`
    ///  Readable | Writable
    ///
    ///
    /// #### `cursor-position`
    ///  Readable
    ///
    ///
    /// #### `ellipsize`
    ///  The preferred place to ellipsize the string, if the label does
    /// not have enough room to display the entire string, specified as a
    /// [`pango::EllipsizeMode`][crate::pango::EllipsizeMode].
    ///
    /// Note that setting this property to a value other than
    /// [`pango::EllipsizeMode::None`][crate::pango::EllipsizeMode::None] has the side-effect that the label requests
    /// only enough space to display the ellipsis "...". In particular, this
    /// means that ellipsizing labels do not work well in notebook tabs, unless
    /// the [`Notebook`][crate::Notebook] tab-expand child property is set to [`true`]. Other ways
    /// to set a label's width are [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] and
    /// [`LabelExt::set_width_chars()`][crate::prelude::LabelExt::set_width_chars()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `justify`
    ///  Readable | Writable
    ///
    ///
    /// #### `label`
    ///  The contents of the label.
    ///
    /// If the string contains [Pango XML markup][PangoMarkupFormat], you will
    /// have to set the [`use-markup`][struct@crate::Label#use-markup] property to [`true`] in order for the
    /// label to display the markup attributes. See also [`LabelExt::set_markup()`][crate::prelude::LabelExt::set_markup()]
    /// for a convenience function that sets both this property and the
    /// [`use-markup`][struct@crate::Label#use-markup] property at the same time.
    ///
    /// If the string contains underlines acting as mnemonics, you will have to
    /// set the [`use-underline`][struct@crate::Label#use-underline] property to [`true`] in order for the label
    /// to display them.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `lines`
    ///  The number of lines to which an ellipsized, wrapping label
    /// should be limited. This property has no effect if the
    /// label is not wrapping or ellipsized. Set this property to
    /// -1 if you don't want to limit the number of lines.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `max-width-chars`
    ///  The desired maximum width of the label, in characters. If this property
    /// is set to -1, the width will be calculated automatically.
    ///
    /// See the section on [text layout][label-text-layout]
    /// for details of how [`width-chars`][struct@crate::Label#width-chars] and [`max-width-chars`][struct@crate::Label#max-width-chars]
    /// determine the width of ellipsized and wrapped labels.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `mnemonic-keyval`
    ///  Readable
    ///
    ///
    /// #### `mnemonic-widget`
    ///  Readable | Writable
    ///
    ///
    /// #### `pattern`
    ///  Writable
    ///
    ///
    /// #### `selectable`
    ///  Readable | Writable
    ///
    ///
    /// #### `selection-bound`
    ///  Readable
    ///
    ///
    /// #### `single-line-mode`
    ///  Whether the label is in single line mode. In single line mode,
    /// the height of the label does not depend on the actual text, it
    /// is always set to ascent + descent of the font. This can be an
    /// advantage in situations where resizing the label because of text
    /// changes would be distracting, e.g. in a statusbar.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `track-visited-links`
    ///  Set this property to [`true`] to make the label track which links
    /// have been visited. It will then apply the [`StateFlags::VISITED`][crate::StateFlags::VISITED]
    /// when rendering this link, in addition to [`StateFlags::LINK`][crate::StateFlags::LINK].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `use-markup`
    ///  Readable | Writable
    ///
    ///
    /// #### `use-underline`
    ///  Readable | Writable
    ///
    ///
    /// #### `width-chars`
    ///  The desired width of the label, in characters. If this property is set to
    /// -1, the width will be calculated automatically.
    ///
    /// See the section on [text layout][label-text-layout]
    /// for details of how [`width-chars`][struct@crate::Label#width-chars] and [`max-width-chars`][struct@crate::Label#max-width-chars]
    /// determine the width of ellipsized and wrapped labels.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `wrap`
    ///  Readable | Writable
    ///
    ///
    /// #### `wrap-mode`
    ///  If line wrapping is on (see the [`wrap`][struct@crate::Label#wrap] property) this controls
    /// how the line wrapping is done. The default is [`pango::WrapMode::Word`][crate::pango::WrapMode::Word], which
    /// means wrap on word boundaries.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `xalign`
    ///  The xalign property determines the horizontal aligment of the label text
    /// inside the labels size allocation. Compare this to [`halign`][struct@crate::Widget#halign],
    /// which determines how the labels size allocation is positioned in the
    /// space available for the label.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `yalign`
    ///  The yalign property determines the vertical aligment of the label text
    /// inside the labels size allocation. Compare this to [`valign`][struct@crate::Widget#valign],
    /// which determines how the labels size allocation is positioned in the
    /// space available for the label.
    ///
    /// Readable | Writable
    /// <details><summary><h4>Misc</h4></summary>
    ///
    ///
    /// #### `xalign`
    ///  The horizontal alignment. A value of 0.0 means left alignment (or right
    /// on RTL locales); a value of 1.0 means right alignment (or left on RTL
    /// locales).
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `xpad`
    ///  The amount of space to add on the left and right of the widget, in
    /// pixels.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `yalign`
    ///  The vertical alignment. A value of 0.0 means top alignment;
    /// a value of 1.0 means bottom alignment.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `ypad`
    ///  The amount of space to add on the top and bottom of the widget, in
    /// pixels.
    ///
    /// Readable | Writable
    /// </details>
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `app-paintable`
    ///  Readable | Writable
    ///
    ///
    /// #### `can-default`
    ///  Readable | Writable
    ///
    ///
    /// #### `can-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `composite-child`
    ///  Readable
    ///
    ///
    /// #### `double-buffered`
    ///  Whether the widget is double buffered.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `events`
    ///  Readable | Writable
    ///
    ///
    /// #### `expand`
    ///  Whether to expand in both directions. Setting this sets both [`hexpand`][struct@crate::Widget#hexpand] and [`vexpand`][struct@crate::Widget#vexpand]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space, see [`Align`][crate::Align]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `has-default`
    ///  Readable | Writable
    ///
    ///
    /// #### `has-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `height-request`
    ///  Readable | Writable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally. See [`WidgetExt::set_hexpand()`][crate::prelude::WidgetExt::set_hexpand()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the [`hexpand`][struct@crate::Widget#hexpand] property. See [`WidgetExt::is_hexpand_set()`][crate::prelude::WidgetExt::is_hexpand_set()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `is-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `margin`
    ///  Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `name`
    ///  Readable | Writable
    ///
    ///
    /// #### `no-show-all`
    ///  Readable | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `parent`
    ///  Readable | Writable
    ///
    ///
    /// #### `receives-default`
    ///  Readable | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `style`
    ///  The style of the widget, which contains information about how it will look (colors, etc).
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `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 | Writable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space, see [`Align`][crate::Align]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically. See [`WidgetExt::set_vexpand()`][crate::prelude::WidgetExt::set_vexpand()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the [`vexpand`][struct@crate::Widget#vexpand] property. See [`WidgetExt::is_vexpand_set()`][crate::prelude::WidgetExt::is_vexpand_set()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `visible`
    ///  Readable | Writable
    ///
    ///
    /// #### `width-request`
    ///  Readable | Writable
    ///
    ///
    /// #### `window`
    ///  The widget's window if it is realized, [`None`] otherwise.
    ///
    /// Readable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `activate-current-link`
    ///  A [keybinding signal][GtkBindingSignal]
    /// which gets emitted when the user activates a link in the label.
    ///
    /// Applications may also emit the signal with `g_signal_emit_by_name()`
    /// if they need to control activation of URIs programmatically.
    ///
    /// The default bindings for this signal are all forms of the Enter key.
    ///
    /// Action
    ///
    ///
    /// #### `activate-link`
    ///  The signal which gets emitted to activate a URI.
    /// Applications may connect to it to override the default behaviour,
    /// which is to call [`show_uri_on_window()`][crate::show_uri_on_window()].
    ///
    ///
    ///
    ///
    /// #### `copy-clipboard`
    ///  The ::copy-clipboard signal is a
    /// [keybinding signal][GtkBindingSignal]
    /// which gets emitted to copy the selection to the clipboard.
    ///
    /// The default binding for this signal is Ctrl-c.
    ///
    /// Action
    ///
    ///
    /// #### `move-cursor`
    ///  The ::move-cursor signal is a
    /// [keybinding signal][GtkBindingSignal]
    /// which gets emitted when the user initiates a cursor movement.
    /// If the cursor is not visible in `entry`, this signal causes
    /// the viewport to be moved instead.
    ///
    /// Applications should not connect to it, but may emit it with
    /// `g_signal_emit_by_name()` if they need to control the cursor
    /// programmatically.
    ///
    /// The default bindings for this signal come in two variants,
    /// the variant with the Shift modifier extends the selection,
    /// the variant without the Shift modifer does not.
    /// There are too many key combinations to list them all here.
    /// - Arrow keys move by individual characters/lines
    /// - Ctrl-arrow key combinations move by words/paragraphs
    /// - Home/End keys move to the ends of the buffer
    ///
    /// Action
    ///
    ///
    /// #### `populate-popup`
    ///  The ::populate-popup signal gets emitted before showing the
    /// context menu of the label. Note that only selectable labels
    /// have context menus.
    ///
    /// If you need to add items to the context menu, connect
    /// to this signal and append your menuitems to the `menu`.
    ///
    ///
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `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.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`LabelExt`][trait@crate::prelude::LabelExt], [`MiscExt`][trait@crate::prelude::MiscExt], [`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 = "GtkLabel")]
    pub struct Label(Object<ffi::GtkLabel, ffi::GtkLabelClass>) @extends Misc, Widget, @implements Buildable;

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

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

    /// Creates a new label with the given text inside it. You can
    /// pass [`None`] to get an empty label widget.
    /// ## `str`
    /// The text of the label
    ///
    /// # Returns
    ///
    /// the new [`Label`][crate::Label]
    #[doc(alias = "gtk_label_new")]
    pub fn new(str: Option<&str>) -> Label {
        assert_initialized_main_thread!();
        unsafe { Widget::from_glib_none(ffi::gtk_label_new(str.to_glib_none().0)).unsafe_cast() }
    }

    /// Creates a new [`Label`][crate::Label], containing the text in `str`.
    ///
    /// If characters in `str` are preceded by an underscore, they are
    /// underlined. If you need a literal underscore character in a label, use
    /// '__' (two underscores). The first underlined character represents a
    /// keyboard accelerator called a mnemonic. The mnemonic key can be used
    /// to activate another widget, chosen automatically, or explicitly using
    /// [`LabelExt::set_mnemonic_widget()`][crate::prelude::LabelExt::set_mnemonic_widget()].
    ///
    /// If [`LabelExt::set_mnemonic_widget()`][crate::prelude::LabelExt::set_mnemonic_widget()] is not called, then the first
    /// activatable ancestor of the [`Label`][crate::Label] will be chosen as the mnemonic
    /// widget. For instance, if the label is inside a button or menu item,
    /// the button or menu item will automatically become the mnemonic widget
    /// and be activated by the mnemonic.
    /// ## `str`
    /// The text of the label, with an underscore in front of the
    ///  mnemonic character
    ///
    /// # Returns
    ///
    /// the new [`Label`][crate::Label]
    #[doc(alias = "gtk_label_new_with_mnemonic")]
    #[doc(alias = "new_with_mnemonic")]
    pub fn with_mnemonic(str: &str) -> Label {
        assert_initialized_main_thread!();
        unsafe {
            Widget::from_glib_none(ffi::gtk_label_new_with_mnemonic(str.to_glib_none().0))
                .unsafe_cast()
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Label`] objects.
    ///
    /// This method returns an instance of [`LabelBuilder`](crate::builders::LabelBuilder) which can be used to create [`Label`] objects.
    pub fn builder() -> LabelBuilder {
        LabelBuilder::new()
    }
}

impl Default for Label {
    fn default() -> Self {
        glib::object::Object::new::<Self>()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Label`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct LabelBuilder {
    builder: glib::object::ObjectBuilder<'static, Label>,
}

impl LabelBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The angle that the baseline of the label makes with the horizontal,
    /// in degrees, measured counterclockwise. An angle of 90 reads from
    /// from bottom to top, an angle of 270, from top to bottom. Ignored
    /// if the label is selectable.
    pub fn angle(self, angle: f64) -> Self {
        Self {
            builder: self.builder.property("angle", angle),
        }
    }

    pub fn attributes(self, attributes: &pango::AttrList) -> Self {
        Self {
            builder: self.builder.property("attributes", attributes.clone()),
        }
    }

    /// The preferred place to ellipsize the string, if the label does
    /// not have enough room to display the entire string, specified as a
    /// [`pango::EllipsizeMode`][crate::pango::EllipsizeMode].
    ///
    /// Note that setting this property to a value other than
    /// [`pango::EllipsizeMode::None`][crate::pango::EllipsizeMode::None] has the side-effect that the label requests
    /// only enough space to display the ellipsis "...". In particular, this
    /// means that ellipsizing labels do not work well in notebook tabs, unless
    /// the [`Notebook`][crate::Notebook] tab-expand child property is set to [`true`]. Other ways
    /// to set a label's width are [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] and
    /// [`LabelExt::set_width_chars()`][crate::prelude::LabelExt::set_width_chars()].
    pub fn ellipsize(self, ellipsize: pango::EllipsizeMode) -> Self {
        Self {
            builder: self.builder.property("ellipsize", ellipsize),
        }
    }

    pub fn justify(self, justify: Justification) -> Self {
        Self {
            builder: self.builder.property("justify", justify),
        }
    }

    /// The contents of the label.
    ///
    /// If the string contains [Pango XML markup][PangoMarkupFormat], you will
    /// have to set the [`use-markup`][struct@crate::Label#use-markup] property to [`true`] in order for the
    /// label to display the markup attributes. See also [`LabelExt::set_markup()`][crate::prelude::LabelExt::set_markup()]
    /// for a convenience function that sets both this property and the
    /// [`use-markup`][struct@crate::Label#use-markup] property at the same time.
    ///
    /// If the string contains underlines acting as mnemonics, you will have to
    /// set the [`use-underline`][struct@crate::Label#use-underline] property to [`true`] in order for the label
    /// to display them.
    pub fn label(self, label: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("label", label.into()),
        }
    }

    /// The number of lines to which an ellipsized, wrapping label
    /// should be limited. This property has no effect if the
    /// label is not wrapping or ellipsized. Set this property to
    /// -1 if you don't want to limit the number of lines.
    pub fn lines(self, lines: i32) -> Self {
        Self {
            builder: self.builder.property("lines", lines),
        }
    }

    /// The desired maximum width of the label, in characters. If this property
    /// is set to -1, the width will be calculated automatically.
    ///
    /// See the section on [text layout][label-text-layout]
    /// for details of how [`width-chars`][struct@crate::Label#width-chars] and [`max-width-chars`][struct@crate::Label#max-width-chars]
    /// determine the width of ellipsized and wrapped labels.
    pub fn max_width_chars(self, max_width_chars: i32) -> Self {
        Self {
            builder: self.builder.property("max-width-chars", max_width_chars),
        }
    }

    pub fn mnemonic_widget(self, mnemonic_widget: &impl IsA<Widget>) -> Self {
        Self {
            builder: self
                .builder
                .property("mnemonic-widget", mnemonic_widget.clone().upcast()),
        }
    }

    pub fn pattern(self, pattern: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("pattern", pattern.into()),
        }
    }

    pub fn selectable(self, selectable: bool) -> Self {
        Self {
            builder: self.builder.property("selectable", selectable),
        }
    }

    /// Whether the label is in single line mode. In single line mode,
    /// the height of the label does not depend on the actual text, it
    /// is always set to ascent + descent of the font. This can be an
    /// advantage in situations where resizing the label because of text
    /// changes would be distracting, e.g. in a statusbar.
    pub fn single_line_mode(self, single_line_mode: bool) -> Self {
        Self {
            builder: self.builder.property("single-line-mode", single_line_mode),
        }
    }

    /// Set this property to [`true`] to make the label track which links
    /// have been visited. It will then apply the [`StateFlags::VISITED`][crate::StateFlags::VISITED]
    /// when rendering this link, in addition to [`StateFlags::LINK`][crate::StateFlags::LINK].
    pub fn track_visited_links(self, track_visited_links: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("track-visited-links", track_visited_links),
        }
    }

    pub fn use_markup(self, use_markup: bool) -> Self {
        Self {
            builder: self.builder.property("use-markup", use_markup),
        }
    }

    pub fn use_underline(self, use_underline: bool) -> Self {
        Self {
            builder: self.builder.property("use-underline", use_underline),
        }
    }

    /// The desired width of the label, in characters. If this property is set to
    /// -1, the width will be calculated automatically.
    ///
    /// See the section on [text layout][label-text-layout]
    /// for details of how [`width-chars`][struct@crate::Label#width-chars] and [`max-width-chars`][struct@crate::Label#max-width-chars]
    /// determine the width of ellipsized and wrapped labels.
    pub fn width_chars(self, width_chars: i32) -> Self {
        Self {
            builder: self.builder.property("width-chars", width_chars),
        }
    }

    pub fn wrap(self, wrap: bool) -> Self {
        Self {
            builder: self.builder.property("wrap", wrap),
        }
    }

    /// If line wrapping is on (see the [`wrap`][struct@crate::Label#wrap] property) this controls
    /// how the line wrapping is done. The default is [`pango::WrapMode::Word`][crate::pango::WrapMode::Word], which
    /// means wrap on word boundaries.
    pub fn wrap_mode(self, wrap_mode: pango::WrapMode) -> Self {
        Self {
            builder: self.builder.property("wrap-mode", wrap_mode),
        }
    }

    /// The xalign property determines the horizontal aligment of the label text
    /// inside the labels size allocation. Compare this to [`halign`][struct@crate::Widget#halign],
    /// which determines how the labels size allocation is positioned in the
    /// space available for the label.
    pub fn xalign(self, xalign: f32) -> Self {
        Self {
            builder: self.builder.property("xalign", xalign),
        }
    }

    /// The yalign property determines the vertical aligment of the label text
    /// inside the labels size allocation. Compare this to [`valign`][struct@crate::Widget#valign],
    /// which determines how the labels size allocation is positioned in the
    /// space available for the label.
    pub fn yalign(self, yalign: f32) -> Self {
        Self {
            builder: self.builder.property("yalign", yalign),
        }
    }

    pub fn app_paintable(self, app_paintable: bool) -> Self {
        Self {
            builder: self.builder.property("app-paintable", app_paintable),
        }
    }

    pub fn can_default(self, can_default: bool) -> Self {
        Self {
            builder: self.builder.property("can-default", can_default),
        }
    }

    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    pub fn events(self, events: gdk::EventMask) -> Self {
        Self {
            builder: self.builder.property("events", events),
        }
    }

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

    /// 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.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// How to distribute horizontal space if widget gets extra space, see [`Align`][crate::Align]
    pub fn halign(self, halign: Align) -> Self {
        Self {
            builder: self.builder.property("halign", halign),
        }
    }

    pub fn has_default(self, has_default: bool) -> Self {
        Self {
            builder: self.builder.property("has-default", has_default),
        }
    }

    pub fn has_focus(self, has_focus: bool) -> Self {
        Self {
            builder: self.builder.property("has-focus", has_focus),
        }
    }

    /// 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.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally. See [`WidgetExt::set_hexpand()`][crate::prelude::WidgetExt::set_hexpand()].
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the [`hexpand`][struct@crate::Widget#hexpand] property. See [`WidgetExt::is_hexpand_set()`][crate::prelude::WidgetExt::is_hexpand_set()].
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    pub fn is_focus(self, is_focus: bool) -> Self {
        Self {
            builder: self.builder.property("is-focus", is_focus),
        }
    }

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

    /// 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.
    pub fn margin_bottom(self, margin_bottom: i32) -> Self {
        Self {
            builder: self.builder.property("margin-bottom", margin_bottom),
        }
    }

    /// 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.
    pub fn margin_end(self, margin_end: i32) -> Self {
        Self {
            builder: self.builder.property("margin-end", margin_end),
        }
    }

    /// 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.
    pub fn margin_start(self, margin_start: i32) -> Self {
        Self {
            builder: self.builder.property("margin-start", margin_start),
        }
    }

    /// 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.
    pub fn margin_top(self, margin_top: i32) -> Self {
        Self {
            builder: self.builder.property("margin-top", margin_top),
        }
    }

    pub fn name(self, name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("name", name.into()),
        }
    }

    pub fn no_show_all(self, no_show_all: bool) -> Self {
        Self {
            builder: self.builder.property("no-show-all", no_show_all),
        }
    }

    /// 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
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    pub fn parent(self, parent: &impl IsA<Container>) -> Self {
        Self {
            builder: self.builder.property("parent", parent.clone().upcast()),
        }
    }

    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    pub fn sensitive(self, sensitive: bool) -> Self {
        Self {
            builder: self.builder.property("sensitive", sensitive),
        }
    }

    /// 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.
    pub fn tooltip_markup(self, tooltip_markup: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("tooltip-markup", tooltip_markup.into()),
        }
    }

    /// 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.
    pub fn tooltip_text(self, tooltip_text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("tooltip-text", tooltip_text.into()),
        }
    }

    /// How to distribute vertical space if widget gets extra space, see [`Align`][crate::Align]
    pub fn valign(self, valign: Align) -> Self {
        Self {
            builder: self.builder.property("valign", valign),
        }
    }

    /// Whether to expand vertically. See [`WidgetExt::set_vexpand()`][crate::prelude::WidgetExt::set_vexpand()].
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the [`vexpand`][struct@crate::Widget#vexpand] property. See [`WidgetExt::is_vexpand_set()`][crate::prelude::WidgetExt::is_vexpand_set()].
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Label`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Label {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}

/// Trait containing all [`struct@Label`] methods.
///
/// # Implementors
///
/// [`AccelLabel`][struct@crate::AccelLabel], [`Label`][struct@crate::Label]
pub trait LabelExt: IsA<Label> + 'static {
    /// Gets the angle of rotation for the label. See
    /// [`set_angle()`][Self::set_angle()].
    ///
    /// # Returns
    ///
    /// the angle of rotation for the label
    #[doc(alias = "gtk_label_get_angle")]
    #[doc(alias = "get_angle")]
    fn angle(&self) -> f64 {
        unsafe { ffi::gtk_label_get_angle(self.as_ref().to_glib_none().0) }
    }

    /// Gets the attribute list that was set on the label using
    /// [`set_attributes()`][Self::set_attributes()], if any. This function does
    /// not reflect attributes that come from the labels markup
    /// (see [`set_markup()`][Self::set_markup()]). If you want to get the
    /// effective attributes for the label, use
    /// pango_layout_get_attribute (gtk_label_get_layout (label)).
    ///
    /// # Returns
    ///
    /// the attribute list, or [`None`]
    ///  if none was set.
    #[doc(alias = "gtk_label_get_attributes")]
    #[doc(alias = "get_attributes")]
    fn attributes(&self) -> Option<pango::AttrList> {
        unsafe {
            from_glib_none(ffi::gtk_label_get_attributes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the URI for the currently active link in the label.
    /// The active link is the one under the mouse pointer or, in a
    /// selectable label, the link in which the text cursor is currently
    /// positioned.
    ///
    /// This function is intended for use in a [`activate-link`][struct@crate::Label#activate-link] handler
    /// or for use in a [`query-tooltip`][struct@crate::Widget#query-tooltip] handler.
    ///
    /// # Returns
    ///
    /// the currently active URI. The string is owned by GTK+ and must
    ///  not be freed or modified.
    #[doc(alias = "gtk_label_get_current_uri")]
    #[doc(alias = "get_current_uri")]
    fn current_uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_label_get_current_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the ellipsizing position of the label. See [`set_ellipsize()`][Self::set_ellipsize()].
    ///
    /// # Returns
    ///
    /// [`pango::EllipsizeMode`][crate::pango::EllipsizeMode]
    #[doc(alias = "gtk_label_get_ellipsize")]
    #[doc(alias = "get_ellipsize")]
    fn ellipsize(&self) -> pango::EllipsizeMode {
        unsafe { from_glib(ffi::gtk_label_get_ellipsize(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the justification of the label. See [`set_justify()`][Self::set_justify()].
    ///
    /// # Returns
    ///
    /// [`Justification`][crate::Justification]
    #[doc(alias = "gtk_label_get_justify")]
    #[doc(alias = "get_justify")]
    fn justify(&self) -> Justification {
        unsafe { from_glib(ffi::gtk_label_get_justify(self.as_ref().to_glib_none().0)) }
    }

    /// Fetches the text from a label widget including any embedded
    /// underlines indicating mnemonics and Pango markup. (See
    /// [`text()`][Self::text()]).
    ///
    /// # Returns
    ///
    /// the text of the label widget. This string is
    ///  owned by the widget and must not be modified or freed.
    #[doc(alias = "gtk_label_get_label")]
    #[doc(alias = "get_label")]
    fn label(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::gtk_label_get_label(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the [`pango::Layout`][crate::pango::Layout] used to display the label.
    /// The layout is useful to e.g. convert text positions to
    /// pixel positions, in combination with [`layout_offsets()`][Self::layout_offsets()].
    /// The returned layout is owned by the `self` so need not be
    /// freed by the caller. The `self` is free to recreate its layout at
    /// any time, so it should be considered read-only.
    ///
    /// # Returns
    ///
    /// the [`pango::Layout`][crate::pango::Layout] for this label
    #[doc(alias = "gtk_label_get_layout")]
    #[doc(alias = "get_layout")]
    fn layout(&self) -> Option<pango::Layout> {
        unsafe { from_glib_none(ffi::gtk_label_get_layout(self.as_ref().to_glib_none().0)) }
    }

    /// Obtains the coordinates where the label will draw the [`pango::Layout`][crate::pango::Layout]
    /// representing the text in the label; useful to convert mouse events
    /// into coordinates inside the [`pango::Layout`][crate::pango::Layout], e.g. to take some action
    /// if some part of the label is clicked. Of course you will need to
    /// create a [`EventBox`][crate::EventBox] to receive the events, and pack the label
    /// inside it, since labels are windowless (they return [`false`] from
    /// [`WidgetExt::has_window()`][crate::prelude::WidgetExt::has_window()]). Remember
    /// when using the [`pango::Layout`][crate::pango::Layout] functions you need to convert to
    /// and from pixels using PANGO_PIXELS() or `PANGO_SCALE`.
    ///
    /// # Returns
    ///
    ///
    /// ## `x`
    /// location to store X offset of layout, or [`None`]
    ///
    /// ## `y`
    /// location to store Y offset of layout, or [`None`]
    #[doc(alias = "gtk_label_get_layout_offsets")]
    #[doc(alias = "get_layout_offsets")]
    fn layout_offsets(&self) -> (i32, i32) {
        unsafe {
            let mut x = std::mem::MaybeUninit::uninit();
            let mut y = std::mem::MaybeUninit::uninit();
            ffi::gtk_label_get_layout_offsets(
                self.as_ref().to_glib_none().0,
                x.as_mut_ptr(),
                y.as_mut_ptr(),
            );
            (x.assume_init(), y.assume_init())
        }
    }

    /// Returns whether lines in the label are automatically wrapped.
    /// See [`set_line_wrap()`][Self::set_line_wrap()].
    ///
    /// # Returns
    ///
    /// [`true`] if the lines of the label are automatically wrapped.
    #[doc(alias = "gtk_label_get_line_wrap")]
    #[doc(alias = "get_line_wrap")]
    fn is_line_wrap(&self) -> bool {
        unsafe { from_glib(ffi::gtk_label_get_line_wrap(self.as_ref().to_glib_none().0)) }
    }

    /// Returns line wrap mode used by the label. See [`set_line_wrap_mode()`][Self::set_line_wrap_mode()].
    ///
    /// # Returns
    ///
    /// [`true`] if the lines of the label are automatically wrapped.
    #[doc(alias = "gtk_label_get_line_wrap_mode")]
    #[doc(alias = "get_line_wrap_mode")]
    fn line_wrap_mode(&self) -> pango::WrapMode {
        unsafe {
            from_glib(ffi::gtk_label_get_line_wrap_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the number of lines to which an ellipsized, wrapping
    /// label should be limited. See [`set_lines()`][Self::set_lines()].
    ///
    /// # Returns
    ///
    /// The number of lines
    #[doc(alias = "gtk_label_get_lines")]
    #[doc(alias = "get_lines")]
    fn lines(&self) -> i32 {
        unsafe { ffi::gtk_label_get_lines(self.as_ref().to_glib_none().0) }
    }

    /// Retrieves the desired maximum width of `self`, in characters. See
    /// [`set_width_chars()`][Self::set_width_chars()].
    ///
    /// # Returns
    ///
    /// the maximum width of the label in characters.
    #[doc(alias = "gtk_label_get_max_width_chars")]
    #[doc(alias = "get_max_width_chars")]
    #[doc(alias = "max-width-chars")]
    fn max_width_chars(&self) -> i32 {
        unsafe { ffi::gtk_label_get_max_width_chars(self.as_ref().to_glib_none().0) }
    }

    /// If the label has been set so that it has an mnemonic key this function
    /// returns the keyval used for the mnemonic accelerator. If there is no
    /// mnemonic set up it returns `GDK_KEY_VoidSymbol`.
    ///
    /// # Returns
    ///
    /// GDK keyval usable for accelerators, or `GDK_KEY_VoidSymbol`
    #[doc(alias = "gtk_label_get_mnemonic_keyval")]
    #[doc(alias = "get_mnemonic_keyval")]
    #[doc(alias = "mnemonic-keyval")]
    fn mnemonic_keyval(&self) -> u32 {
        unsafe { ffi::gtk_label_get_mnemonic_keyval(self.as_ref().to_glib_none().0) }
    }

    /// Retrieves the target of the mnemonic (keyboard shortcut) of this
    /// label. See [`set_mnemonic_widget()`][Self::set_mnemonic_widget()].
    ///
    /// # Returns
    ///
    /// the target of the label’s mnemonic,
    ///  or [`None`] if none has been set and the default algorithm will be used.
    #[doc(alias = "gtk_label_get_mnemonic_widget")]
    #[doc(alias = "get_mnemonic_widget")]
    #[doc(alias = "mnemonic-widget")]
    fn mnemonic_widget(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_label_get_mnemonic_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value set by [`set_selectable()`][Self::set_selectable()].
    ///
    /// # Returns
    ///
    /// [`true`] if the user can copy text from the label
    #[doc(alias = "gtk_label_get_selectable")]
    #[doc(alias = "get_selectable")]
    #[doc(alias = "selectable")]
    fn is_selectable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_label_get_selectable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the selected range of characters in the label, returning [`true`]
    /// if there’s a selection.
    ///
    /// # Returns
    ///
    /// [`true`] if selection is non-empty
    ///
    /// ## `start`
    /// return location for start of selection, as a character offset
    ///
    /// ## `end`
    /// return location for end of selection, as a character offset
    #[doc(alias = "gtk_label_get_selection_bounds")]
    #[doc(alias = "get_selection_bounds")]
    fn selection_bounds(&self) -> Option<(i32, i32)> {
        unsafe {
            let mut start = std::mem::MaybeUninit::uninit();
            let mut end = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_label_get_selection_bounds(
                self.as_ref().to_glib_none().0,
                start.as_mut_ptr(),
                end.as_mut_ptr(),
            ));
            if ret {
                Some((start.assume_init(), end.assume_init()))
            } else {
                None
            }
        }
    }

    /// Returns whether the label is in single line mode.
    ///
    /// # Returns
    ///
    /// [`true`] when the label is in single line mode.
    #[doc(alias = "gtk_label_get_single_line_mode")]
    #[doc(alias = "get_single_line_mode")]
    #[doc(alias = "single-line-mode")]
    fn is_single_line_mode(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_label_get_single_line_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Fetches the text from a label widget, as displayed on the
    /// screen. This does not include any embedded underlines
    /// indicating mnemonics or Pango markup. (See [`label()`][Self::label()])
    ///
    /// # Returns
    ///
    /// the text in the label widget. This is the internal
    ///  string used by the label, and must not be modified.
    #[doc(alias = "gtk_label_get_text")]
    #[doc(alias = "get_text")]
    fn text(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::gtk_label_get_text(self.as_ref().to_glib_none().0)) }
    }

    /// Returns whether the label is currently keeping track
    /// of clicked links.
    ///
    /// # Returns
    ///
    /// [`true`] if clicked links are remembered
    #[doc(alias = "gtk_label_get_track_visited_links")]
    #[doc(alias = "get_track_visited_links")]
    #[doc(alias = "track-visited-links")]
    fn tracks_visited_links(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_label_get_track_visited_links(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the label’s text is interpreted as marked up with
    /// the [Pango text markup language][PangoMarkupFormat].
    /// See gtk_label_set_use_markup ().
    ///
    /// # Returns
    ///
    /// [`true`] if the label’s text will be parsed for markup.
    #[doc(alias = "gtk_label_get_use_markup")]
    #[doc(alias = "get_use_markup")]
    #[doc(alias = "use-markup")]
    fn uses_markup(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_label_get_use_markup(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether an embedded underline in the label indicates a
    /// mnemonic. See [`set_use_underline()`][Self::set_use_underline()].
    ///
    /// # Returns
    ///
    /// [`true`] whether an embedded underline in the label indicates
    ///  the mnemonic accelerator keys.
    #[doc(alias = "gtk_label_get_use_underline")]
    #[doc(alias = "get_use_underline")]
    #[doc(alias = "use-underline")]
    fn uses_underline(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_label_get_use_underline(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves the desired width of `self`, in characters. See
    /// [`set_width_chars()`][Self::set_width_chars()].
    ///
    /// # Returns
    ///
    /// the width of the label in characters.
    #[doc(alias = "gtk_label_get_width_chars")]
    #[doc(alias = "get_width_chars")]
    #[doc(alias = "width-chars")]
    fn width_chars(&self) -> i32 {
        unsafe { ffi::gtk_label_get_width_chars(self.as_ref().to_glib_none().0) }
    }

    /// Gets the [`xalign`][struct@crate::Label#xalign] property for `self`.
    ///
    /// # Returns
    ///
    /// the xalign property
    #[doc(alias = "gtk_label_get_xalign")]
    #[doc(alias = "get_xalign")]
    fn xalign(&self) -> f32 {
        unsafe { ffi::gtk_label_get_xalign(self.as_ref().to_glib_none().0) }
    }

    /// Gets the [`yalign`][struct@crate::Label#yalign] property for `self`.
    ///
    /// # Returns
    ///
    /// the yalign property
    #[doc(alias = "gtk_label_get_yalign")]
    #[doc(alias = "get_yalign")]
    fn yalign(&self) -> f32 {
        unsafe { ffi::gtk_label_get_yalign(self.as_ref().to_glib_none().0) }
    }

    /// Selects a range of characters in the label, if the label is selectable.
    /// See [`set_selectable()`][Self::set_selectable()]. If the label is not selectable,
    /// this function has no effect. If `start_offset` or
    /// `end_offset` are -1, then the end of the label will be substituted.
    /// ## `start_offset`
    /// start offset (in characters not bytes)
    /// ## `end_offset`
    /// end offset (in characters not bytes)
    #[doc(alias = "gtk_label_select_region")]
    fn select_region(&self, start_offset: i32, end_offset: i32) {
        unsafe {
            ffi::gtk_label_select_region(self.as_ref().to_glib_none().0, start_offset, end_offset);
        }
    }

    /// Sets the angle of rotation for the label. An angle of 90 reads from
    /// from bottom to top, an angle of 270, from top to bottom. The angle
    /// setting for the label is ignored if the label is selectable,
    /// wrapped, or ellipsized.
    /// ## `angle`
    /// the angle that the baseline of the label makes with
    ///  the horizontal, in degrees, measured counterclockwise
    #[doc(alias = "gtk_label_set_angle")]
    #[doc(alias = "angle")]
    fn set_angle(&self, angle: f64) {
        unsafe {
            ffi::gtk_label_set_angle(self.as_ref().to_glib_none().0, angle);
        }
    }

    /// Sets a [`pango::AttrList`][crate::pango::AttrList]; the attributes in the list are applied to the
    /// label text.
    ///
    /// The attributes set with this function will be applied
    /// and merged with any other attributes previously effected by way
    /// of the [`use-underline`][struct@crate::Label#use-underline] or [`use-markup`][struct@crate::Label#use-markup] properties.
    /// While it is not recommended to mix markup strings with manually set
    /// attributes, if you must; know that the attributes will be applied
    /// to the label after the markup string is parsed.
    /// ## `attrs`
    /// a [`pango::AttrList`][crate::pango::AttrList], or [`None`]
    #[doc(alias = "gtk_label_set_attributes")]
    #[doc(alias = "attributes")]
    fn set_attributes(&self, attrs: Option<&pango::AttrList>) {
        unsafe {
            ffi::gtk_label_set_attributes(self.as_ref().to_glib_none().0, attrs.to_glib_none().0);
        }
    }

    /// Sets the mode used to ellipsize (add an ellipsis: "...") to the text
    /// if there is not enough space to render the entire string.
    /// ## `mode`
    /// a [`pango::EllipsizeMode`][crate::pango::EllipsizeMode]
    #[doc(alias = "gtk_label_set_ellipsize")]
    #[doc(alias = "ellipsize")]
    fn set_ellipsize(&self, mode: pango::EllipsizeMode) {
        unsafe {
            ffi::gtk_label_set_ellipsize(self.as_ref().to_glib_none().0, mode.into_glib());
        }
    }

    /// Sets the alignment of the lines in the text of the label relative to
    /// each other. [`Justification::Left`][crate::Justification::Left] is the default value when the widget is
    /// first created with [`Label::new()`][crate::Label::new()]. If you instead want to set the
    /// alignment of the label as a whole, use [`WidgetExt::set_halign()`][crate::prelude::WidgetExt::set_halign()] instead.
    /// [`set_justify()`][Self::set_justify()] has no effect on labels containing only a
    /// single line.
    /// ## `jtype`
    /// a [`Justification`][crate::Justification]
    #[doc(alias = "gtk_label_set_justify")]
    #[doc(alias = "justify")]
    fn set_justify(&self, jtype: Justification) {
        unsafe {
            ffi::gtk_label_set_justify(self.as_ref().to_glib_none().0, jtype.into_glib());
        }
    }

    /// Sets the text of the label. The label is interpreted as
    /// including embedded underlines and/or Pango markup depending
    /// on the values of the [`use-underline`][struct@crate::Label#use-underline] and
    /// [`use-markup`][struct@crate::Label#use-markup] properties.
    /// ## `str`
    /// the new text to set for the label
    #[doc(alias = "gtk_label_set_label")]
    #[doc(alias = "label")]
    fn set_label(&self, str: &str) {
        unsafe {
            ffi::gtk_label_set_label(self.as_ref().to_glib_none().0, str.to_glib_none().0);
        }
    }

    /// Toggles line wrapping within the [`Label`][crate::Label] widget. [`true`] makes it break
    /// lines if text exceeds the widget’s size. [`false`] lets the text get cut off
    /// by the edge of the widget if it exceeds the widget size.
    ///
    /// Note that setting line wrapping to [`true`] does not make the label
    /// wrap at its parent container’s width, because GTK+ widgets
    /// conceptually can’t make their requisition depend on the parent
    /// container’s size. For a label that wraps at a specific position,
    /// set the label’s width using [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()].
    /// ## `wrap`
    /// the setting
    #[doc(alias = "gtk_label_set_line_wrap")]
    fn set_line_wrap(&self, wrap: bool) {
        unsafe {
            ffi::gtk_label_set_line_wrap(self.as_ref().to_glib_none().0, wrap.into_glib());
        }
    }

    /// If line wrapping is on (see [`set_line_wrap()`][Self::set_line_wrap()]) this controls how
    /// the line wrapping is done. The default is [`pango::WrapMode::Word`][crate::pango::WrapMode::Word] which means
    /// wrap on word boundaries.
    /// ## `wrap_mode`
    /// the line wrapping mode
    #[doc(alias = "gtk_label_set_line_wrap_mode")]
    fn set_line_wrap_mode(&self, wrap_mode: pango::WrapMode) {
        unsafe {
            ffi::gtk_label_set_line_wrap_mode(
                self.as_ref().to_glib_none().0,
                wrap_mode.into_glib(),
            );
        }
    }

    /// Sets the number of lines to which an ellipsized, wrapping label
    /// should be limited. This has no effect if the label is not wrapping
    /// or ellipsized. Set this to -1 if you don’t want to limit the
    /// number of lines.
    /// ## `lines`
    /// the desired number of lines, or -1
    #[doc(alias = "gtk_label_set_lines")]
    #[doc(alias = "lines")]
    fn set_lines(&self, lines: i32) {
        unsafe {
            ffi::gtk_label_set_lines(self.as_ref().to_glib_none().0, lines);
        }
    }

    /// Parses `str` which is marked up with the
    /// [Pango text markup language][PangoMarkupFormat], setting the
    /// label’s text and attribute list based on the parse results.
    ///
    /// If the `str` is external data, you may need to escape it with
    /// `g_markup_escape_text()` or `g_markup_printf_escaped()`:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// GtkWidget *label = gtk_label_new (NULL);
    /// const char *str = "some text";
    /// const char *format = "<span style=\"italic\">\%s</span>";
    /// char *markup;
    ///
    /// markup = g_markup_printf_escaped (format, str);
    /// gtk_label_set_markup (GTK_LABEL (label), markup);
    /// g_free (markup);
    /// ```
    ///
    /// This function will set the [`use-markup`][struct@crate::Label#use-markup] property to [`true`] as
    /// a side effect.
    ///
    /// If you set the label contents using the [`label`][struct@crate::Label#label] property you
    /// should also ensure that you set the [`use-markup`][struct@crate::Label#use-markup] property
    /// accordingly.
    ///
    /// See also: [`set_text()`][Self::set_text()]
    /// ## `str`
    /// a markup string (see [Pango markup format][PangoMarkupFormat])
    #[doc(alias = "gtk_label_set_markup")]
    fn set_markup(&self, str: &str) {
        unsafe {
            ffi::gtk_label_set_markup(self.as_ref().to_glib_none().0, str.to_glib_none().0);
        }
    }

    /// Parses `str` which is marked up with the
    /// [Pango text markup language][PangoMarkupFormat],
    /// setting the label’s text and attribute list based on the parse results.
    /// If characters in `str` are preceded by an underscore, they are underlined
    /// indicating that they represent a keyboard accelerator called a mnemonic.
    ///
    /// The mnemonic key can be used to activate another widget, chosen
    /// automatically, or explicitly using [`set_mnemonic_widget()`][Self::set_mnemonic_widget()].
    /// ## `str`
    /// a markup string (see
    ///  [Pango markup format][PangoMarkupFormat])
    #[doc(alias = "gtk_label_set_markup_with_mnemonic")]
    fn set_markup_with_mnemonic(&self, str: &str) {
        unsafe {
            ffi::gtk_label_set_markup_with_mnemonic(
                self.as_ref().to_glib_none().0,
                str.to_glib_none().0,
            );
        }
    }

    /// Sets the desired maximum width in characters of `self` to `n_chars`.
    /// ## `n_chars`
    /// the new desired maximum width, in characters.
    #[doc(alias = "gtk_label_set_max_width_chars")]
    #[doc(alias = "max-width-chars")]
    fn set_max_width_chars(&self, n_chars: i32) {
        unsafe {
            ffi::gtk_label_set_max_width_chars(self.as_ref().to_glib_none().0, n_chars);
        }
    }

    /// If the label has been set so that it has an mnemonic key (using
    /// i.e. [`set_markup_with_mnemonic()`][Self::set_markup_with_mnemonic()],
    /// [`set_text_with_mnemonic()`][Self::set_text_with_mnemonic()], [`Label::with_mnemonic()`][crate::Label::with_mnemonic()]
    /// or the “use_underline” property) the label can be associated with a
    /// widget that is the target of the mnemonic. When the label is inside
    /// a widget (like a [`Button`][crate::Button] or a [`Notebook`][crate::Notebook] tab) it is
    /// automatically associated with the correct widget, but sometimes
    /// (i.e. when the target is a [`Entry`][crate::Entry] next to the label) you need to
    /// set it explicitly using this function.
    ///
    /// The target widget will be accelerated by emitting the
    /// GtkWidget::mnemonic-activate signal on it. The default handler for
    /// this signal will activate the widget if there are no mnemonic collisions
    /// and toggle focus between the colliding widgets otherwise.
    /// ## `widget`
    /// the target [`Widget`][crate::Widget], or [`None`] to unset
    #[doc(alias = "gtk_label_set_mnemonic_widget")]
    #[doc(alias = "mnemonic-widget")]
    fn set_mnemonic_widget(&self, widget: Option<&impl IsA<Widget>>) {
        unsafe {
            ffi::gtk_label_set_mnemonic_widget(
                self.as_ref().to_glib_none().0,
                widget.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// The pattern of underlines you want under the existing text within the
    /// [`Label`][crate::Label] widget. For example if the current text of the label says
    /// “FooBarBaz” passing a pattern of “___ ___” will underline
    /// “Foo” and “Baz” but not “Bar”.
    /// ## `pattern`
    /// The pattern as described above.
    #[doc(alias = "gtk_label_set_pattern")]
    #[doc(alias = "pattern")]
    fn set_pattern(&self, pattern: &str) {
        unsafe {
            ffi::gtk_label_set_pattern(self.as_ref().to_glib_none().0, pattern.to_glib_none().0);
        }
    }

    /// Selectable labels allow the user to select text from the label, for
    /// copy-and-paste.
    /// ## `setting`
    /// [`true`] to allow selecting text in the label
    #[doc(alias = "gtk_label_set_selectable")]
    #[doc(alias = "selectable")]
    fn set_selectable(&self, setting: bool) {
        unsafe {
            ffi::gtk_label_set_selectable(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    /// Sets whether the label is in single line mode.
    /// ## `single_line_mode`
    /// [`true`] if the label should be in single line mode
    #[doc(alias = "gtk_label_set_single_line_mode")]
    #[doc(alias = "single-line-mode")]
    fn set_single_line_mode(&self, single_line_mode: bool) {
        unsafe {
            ffi::gtk_label_set_single_line_mode(
                self.as_ref().to_glib_none().0,
                single_line_mode.into_glib(),
            );
        }
    }

    /// Sets the text within the [`Label`][crate::Label] widget. It overwrites any text that
    /// was there before.
    ///
    /// This function will clear any previously set mnemonic accelerators, and
    /// set the [`use-underline`][struct@crate::Label#use-underline] property to [`false`] as a side effect.
    ///
    /// This function will set the [`use-markup`][struct@crate::Label#use-markup] property to [`false`]
    /// as a side effect.
    ///
    /// See also: [`set_markup()`][Self::set_markup()]
    /// ## `str`
    /// The text you want to set
    #[doc(alias = "gtk_label_set_text")]
    fn set_text(&self, str: &str) {
        unsafe {
            ffi::gtk_label_set_text(self.as_ref().to_glib_none().0, str.to_glib_none().0);
        }
    }

    /// Sets the label’s text from the string `str`.
    /// If characters in `str` are preceded by an underscore, they are underlined
    /// indicating that they represent a keyboard accelerator called a mnemonic.
    /// The mnemonic key can be used to activate another widget, chosen
    /// automatically, or explicitly using [`set_mnemonic_widget()`][Self::set_mnemonic_widget()].
    /// ## `str`
    /// a string
    #[doc(alias = "gtk_label_set_text_with_mnemonic")]
    fn set_text_with_mnemonic(&self, str: &str) {
        unsafe {
            ffi::gtk_label_set_text_with_mnemonic(
                self.as_ref().to_glib_none().0,
                str.to_glib_none().0,
            );
        }
    }

    /// Sets whether the label should keep track of clicked
    /// links (and use a different color for them).
    /// ## `track_links`
    /// [`true`] to track visited links
    #[doc(alias = "gtk_label_set_track_visited_links")]
    #[doc(alias = "track-visited-links")]
    fn set_track_visited_links(&self, track_links: bool) {
        unsafe {
            ffi::gtk_label_set_track_visited_links(
                self.as_ref().to_glib_none().0,
                track_links.into_glib(),
            );
        }
    }

    /// Sets whether the text of the label contains markup in
    /// [Pango’s text markup language][PangoMarkupFormat].
    /// See [`set_markup()`][Self::set_markup()].
    /// ## `setting`
    /// [`true`] if the label’s text should be parsed for markup.
    #[doc(alias = "gtk_label_set_use_markup")]
    #[doc(alias = "use-markup")]
    fn set_use_markup(&self, setting: bool) {
        unsafe {
            ffi::gtk_label_set_use_markup(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    /// If true, an underline in the text indicates the next character should be
    /// used for the mnemonic accelerator key.
    /// ## `setting`
    /// [`true`] if underlines in the text indicate mnemonics
    #[doc(alias = "gtk_label_set_use_underline")]
    #[doc(alias = "use-underline")]
    fn set_use_underline(&self, setting: bool) {
        unsafe {
            ffi::gtk_label_set_use_underline(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    /// Sets the desired width in characters of `self` to `n_chars`.
    /// ## `n_chars`
    /// the new desired width, in characters.
    #[doc(alias = "gtk_label_set_width_chars")]
    #[doc(alias = "width-chars")]
    fn set_width_chars(&self, n_chars: i32) {
        unsafe {
            ffi::gtk_label_set_width_chars(self.as_ref().to_glib_none().0, n_chars);
        }
    }

    /// Sets the [`xalign`][struct@crate::Label#xalign] property for `self`.
    /// ## `xalign`
    /// the new xalign value, between 0 and 1
    #[doc(alias = "gtk_label_set_xalign")]
    #[doc(alias = "xalign")]
    fn set_xalign(&self, xalign: f32) {
        unsafe {
            ffi::gtk_label_set_xalign(self.as_ref().to_glib_none().0, xalign);
        }
    }

    /// Sets the [`yalign`][struct@crate::Label#yalign] property for `self`.
    /// ## `yalign`
    /// the new yalign value, between 0 and 1
    #[doc(alias = "gtk_label_set_yalign")]
    #[doc(alias = "yalign")]
    fn set_yalign(&self, yalign: f32) {
        unsafe {
            ffi::gtk_label_set_yalign(self.as_ref().to_glib_none().0, yalign);
        }
    }

    #[doc(alias = "cursor-position")]
    fn cursor_position(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "cursor-position")
    }

    #[doc(alias = "selection-bound")]
    fn selection_bound(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "selection-bound")
    }

    fn wraps(&self) -> bool {
        ObjectExt::property(self.as_ref(), "wrap")
    }

    fn set_wrap(&self, wrap: bool) {
        ObjectExt::set_property(self.as_ref(), "wrap", wrap)
    }

    /// If line wrapping is on (see the [`wrap`][struct@crate::Label#wrap] property) this controls
    /// how the line wrapping is done. The default is [`pango::WrapMode::Word`][crate::pango::WrapMode::Word], which
    /// means wrap on word boundaries.
    #[doc(alias = "wrap-mode")]
    fn wrap_mode(&self) -> pango::WrapMode {
        ObjectExt::property(self.as_ref(), "wrap-mode")
    }

    /// If line wrapping is on (see the [`wrap`][struct@crate::Label#wrap] property) this controls
    /// how the line wrapping is done. The default is [`pango::WrapMode::Word`][crate::pango::WrapMode::Word], which
    /// means wrap on word boundaries.
    #[doc(alias = "wrap-mode")]
    fn set_wrap_mode(&self, wrap_mode: pango::WrapMode) {
        ObjectExt::set_property(self.as_ref(), "wrap-mode", wrap_mode)
    }

    /// A [keybinding signal][GtkBindingSignal]
    /// which gets emitted when the user activates a link in the label.
    ///
    /// Applications may also emit the signal with `g_signal_emit_by_name()`
    /// if they need to control activation of URIs programmatically.
    ///
    /// The default bindings for this signal are all forms of the Enter key.
    #[doc(alias = "activate-current-link")]
    fn connect_activate_current_link<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn activate_current_link_trampoline<
            P: IsA<Label>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkLabel,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Label::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"activate-current-link".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    activate_current_link_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_activate_current_link(&self) {
        self.emit_by_name::<()>("activate-current-link", &[]);
    }

    /// The signal which gets emitted to activate a URI.
    /// Applications may connect to it to override the default behaviour,
    /// which is to call [`show_uri_on_window()`][crate::show_uri_on_window()].
    /// ## `uri`
    /// the URI that is activated
    ///
    /// # Returns
    ///
    /// [`true`] if the link has been activated
    #[doc(alias = "activate-link")]
    fn connect_activate_link<F: Fn(&Self, &str) -> glib::Propagation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn activate_link_trampoline<
            P: IsA<Label>,
            F: Fn(&P, &str) -> glib::Propagation + 'static,
        >(
            this: *mut ffi::GtkLabel,
            uri: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Label::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(uri),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"activate-link".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    activate_link_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::copy-clipboard signal is a
    /// [keybinding signal][GtkBindingSignal]
    /// which gets emitted to copy the selection to the clipboard.
    ///
    /// The default binding for this signal is Ctrl-c.
    #[doc(alias = "copy-clipboard")]
    fn connect_copy_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn copy_clipboard_trampoline<P: IsA<Label>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkLabel,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Label::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"copy-clipboard".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    copy_clipboard_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_copy_clipboard(&self) {
        self.emit_by_name::<()>("copy-clipboard", &[]);
    }

    /// The ::move-cursor signal is a
    /// [keybinding signal][GtkBindingSignal]
    /// which gets emitted when the user initiates a cursor movement.
    /// If the cursor is not visible in `entry`, this signal causes
    /// the viewport to be moved instead.
    ///
    /// Applications should not connect to it, but may emit it with
    /// `g_signal_emit_by_name()` if they need to control the cursor
    /// programmatically.
    ///
    /// The default bindings for this signal come in two variants,
    /// the variant with the Shift modifier extends the selection,
    /// the variant without the Shift modifer does not.
    /// There are too many key combinations to list them all here.
    /// - Arrow keys move by individual characters/lines
    /// - Ctrl-arrow key combinations move by words/paragraphs
    /// - Home/End keys move to the ends of the buffer
    /// ## `step`
    /// the granularity of the move, as a [`MovementStep`][crate::MovementStep]
    /// ## `count`
    /// the number of `step` units to move
    /// ## `extend_selection`
    /// [`true`] if the move should extend the selection
    #[doc(alias = "move-cursor")]
    fn connect_move_cursor<F: Fn(&Self, MovementStep, i32, bool) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn move_cursor_trampoline<
            P: IsA<Label>,
            F: Fn(&P, MovementStep, i32, bool) + 'static,
        >(
            this: *mut ffi::GtkLabel,
            step: ffi::GtkMovementStep,
            count: std::ffi::c_int,
            extend_selection: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Label::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(step),
                    count,
                    from_glib(extend_selection),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"move-cursor".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    move_cursor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_move_cursor(&self, step: MovementStep, count: i32, extend_selection: bool) {
        self.emit_by_name::<()>("move-cursor", &[&step, &count, &extend_selection]);
    }

    /// The ::populate-popup signal gets emitted before showing the
    /// context menu of the label. Note that only selectable labels
    /// have context menus.
    ///
    /// If you need to add items to the context menu, connect
    /// to this signal and append your menuitems to the `menu`.
    /// ## `menu`
    /// the menu that is being populated
    #[doc(alias = "populate-popup")]
    fn connect_populate_popup<F: Fn(&Self, &Menu) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn populate_popup_trampoline<
            P: IsA<Label>,
            F: Fn(&P, &Menu) + 'static,
        >(
            this: *mut ffi::GtkLabel,
            menu: *mut ffi::GtkMenu,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Label::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(menu),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"populate-popup".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    populate_popup_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<O: IsA<Label>> LabelExt for O {}