gtk4/auto/

progress_bar.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

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
use crate::AccessibleRange;
use crate::{
    Accessible, AccessibleRole, Align, Buildable, ConstraintTarget, LayoutManager, Orientable,
    Orientation, Overflow, Widget, ffi,
};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
glib::wrapper! {
    /// Displays the progress of a long-running operation.
    ///
    /// [`ProgressBar`][crate::ProgressBar] provides a visual clue that processing is underway.
    /// It can be used in two different modes: percentage mode and activity mode.
    ///
    /// <picture>
    ///   <source srcset="progressbar-dark.png" media="(prefers-color-scheme: dark)">
    ///   <img alt="An example GtkProgressBar" src="progressbar.png">
    /// </picture>
    ///
    /// When an application can determine how much work needs to take place
    /// (e.g. read a fixed number of bytes from a file) and can monitor its
    /// progress, it can use the [`ProgressBar`][crate::ProgressBar] in percentage mode and the
    /// user sees a growing bar indicating the percentage of the work that
    /// has been completed. In this mode, the application is required to call
    /// [`set_fraction()`][Self::set_fraction()] periodically to update the progress bar.
    ///
    /// When an application has no accurate way of knowing the amount of work
    /// to do, it can use the [`ProgressBar`][crate::ProgressBar] in activity mode, which shows
    /// activity by a block moving back and forth within the progress area. In
    /// this mode, the application is required to call [`pulse()`][Self::pulse()]
    /// periodically to update the progress bar.
    ///
    /// There is quite a bit of flexibility provided to control the appearance
    /// of the [`ProgressBar`][crate::ProgressBar]. Functions are provided to control the orientation
    /// of the bar, optional text can be displayed along with the bar, and the
    /// step size used in activity mode can be set.
    ///
    /// # CSS nodes
    ///
    /// ```text
    /// progressbar[.osd]
    /// ├── [text]
    /// ╰── trough[.empty][.full]
    ///     ╰── progress[.pulse]
    /// ```
    ///
    /// [`ProgressBar`][crate::ProgressBar] has a main CSS node with name progressbar and subnodes with
    /// names text and trough, of which the latter has a subnode named progress. The
    /// text subnode is only present if text is shown. The progress subnode has the
    /// style class .pulse when in activity mode. It gets the style classes .left,
    /// .right, .top or .bottom added when the progress 'touches' the corresponding
    /// end of the GtkProgressBar. The .osd class on the progressbar node is for use
    /// in overlays like the one Epiphany has for page loading progress.
    ///
    /// # Accessibility
    ///
    /// [`ProgressBar`][crate::ProgressBar] uses the [enum@Gtk.AccessibleRole.progress_bar] role
    /// and sets the [enum@Gtk.AccessibleProperty.value_min], [enum@Gtk.AccessibleProperty.value_max] and [enum@Gtk.AccessibleProperty.value_now] properties to reflect
    /// the progress.
    ///
    /// ## Properties
    ///
    ///
    /// #### `ellipsize`
    ///  The preferred place to ellipsize the string.
    ///
    /// The text will be ellipsized if the progress bar 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 progress bar requests
    /// only enough space to display the ellipsis ("..."). Another means to set a
    /// progress bar's width is [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `fraction`
    ///  The fraction of total work that has been completed.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `inverted`
    ///  Invert the direction in which the progress bar grows.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pulse-step`
    ///  The fraction of total progress to move the bounding block when pulsed.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `show-text`
    ///  Sets whether the progress bar will show a text in addition
    /// to the bar itself.
    ///
    /// The shown text is either the value of the [`text`][struct@crate::ProgressBar#text]
    /// property or, if that is [`None`], the [`fraction`][struct@crate::ProgressBar#fraction]
    /// value, as a percentage.
    ///
    /// To make a progress bar that is styled and sized suitably for showing text
    /// (even if the actual text is blank), set [`show-text`][struct@crate::ProgressBar#show-text]
    /// to [`true`] and [`text`][struct@crate::ProgressBar#text] to the empty string (not [`None`]).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `text`
    ///  Text to be displayed in the progress bar.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `can-focus`
    ///  Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `can-target`
    ///  Whether the widget can receive pointer events.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-classes`
    ///  A list of css classes applied to this widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-name`
    ///  The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `cursor`
    ///  The cursor used by @widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focusable`
    ///  Whether this widget itself will accept the input focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-default`
    ///  Whether the widget is the default widget.
    ///
    /// Readable
    ///
    ///
    /// #### `has-focus`
    ///  Whether the widget has the input focus.
    ///
    /// Readable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of the [`query-tooltip`][struct@crate::Widget#query-tooltip]
    /// signal on @widget.
    ///
    /// A true value indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the `hexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `layout-manager`
    ///  The [`LayoutManager`][crate::LayoutManager] instance to use to compute
    /// the preferred size of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `limit-events`
    ///  Makes this widget act like a modal dialog, with respect to
    /// event delivery.
    ///
    /// Global event controllers will not handle events with targets
    /// inside the widget, unless they are set up to ignore propagation
    /// limits. See [`EventControllerExt::set_propagation_limit()`][crate::prelude::EventControllerExt::set_propagation_limit()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-end`
    ///  Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-start`
    ///  Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-top`
    ///  Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `name`
    ///  The name of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `overflow`
    ///  How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `parent`
    ///  The parent widget of this widget.
    ///
    /// Readable
    ///
    ///
    /// #### `receives-default`
    ///  Whether the widget will receive the default action when it is focused.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `root`
    ///  The [`Root`][crate::Root] widget of the widget tree containing this widget.
    ///
    /// This will be `NULL` if the widget is not contained in a root widget.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Whether the widget responds to input.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the `vexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible`
    ///  Whether the widget is visible.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `width-request`
    ///  Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Accessible</h4></summary>
    ///
    ///
    /// #### `accessible-role`
    ///  The accessible role of the given [`Accessible`][crate::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Orientable</h4></summary>
    ///
    ///
    /// #### `orientation`
    ///  The orientation of the orientable.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`AccessibleExt`][trait@crate::prelude::AccessibleExt], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ConstraintTargetExt`][trait@crate::prelude::ConstraintTargetExt], [`AccessibleRangeExt`][trait@crate::prelude::AccessibleRangeExt], [`OrientableExt`][trait@crate::prelude::OrientableExt], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkProgressBar")]
    pub struct ProgressBar(Object<ffi::GtkProgressBar>) @extends Widget, @implements Accessible, Buildable, ConstraintTarget, AccessibleRange, Orientable;

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

#[cfg(not(any(feature = "v4_10")))]
glib::wrapper! {
    #[doc(alias = "GtkProgressBar")]
    pub struct ProgressBar(Object<ffi::GtkProgressBar>) @extends Widget, @implements Accessible, Buildable, ConstraintTarget, Orientable;

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

impl ProgressBar {
    /// Creates a new [`ProgressBar`][crate::ProgressBar].
    ///
    /// # Returns
    ///
    /// a [`ProgressBar`][crate::ProgressBar].
    #[doc(alias = "gtk_progress_bar_new")]
    pub fn new() -> ProgressBar {
        assert_initialized_main_thread!();
        unsafe { Widget::from_glib_none(ffi::gtk_progress_bar_new()).unsafe_cast() }
    }

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

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

    /// Returns the current fraction of the task that’s been completed.
    ///
    /// # Returns
    ///
    /// a fraction from 0.0 to 1.0
    #[doc(alias = "gtk_progress_bar_get_fraction")]
    #[doc(alias = "get_fraction")]
    pub fn fraction(&self) -> f64 {
        unsafe { ffi::gtk_progress_bar_get_fraction(self.to_glib_none().0) }
    }

    /// Returns whether the progress bar is inverted.
    ///
    /// # Returns
    ///
    /// [`true`] if the progress bar is inverted
    #[doc(alias = "gtk_progress_bar_get_inverted")]
    #[doc(alias = "get_inverted")]
    #[doc(alias = "inverted")]
    pub fn is_inverted(&self) -> bool {
        unsafe { from_glib(ffi::gtk_progress_bar_get_inverted(self.to_glib_none().0)) }
    }

    /// Retrieves the pulse step.
    ///
    /// See [`set_pulse_step()`][Self::set_pulse_step()].
    ///
    /// # Returns
    ///
    /// a fraction from 0.0 to 1.0
    #[doc(alias = "gtk_progress_bar_get_pulse_step")]
    #[doc(alias = "get_pulse_step")]
    #[doc(alias = "pulse-step")]
    pub fn pulse_step(&self) -> f64 {
        unsafe { ffi::gtk_progress_bar_get_pulse_step(self.to_glib_none().0) }
    }

    /// Returns whether the [`ProgressBar`][crate::ProgressBar] shows text.
    ///
    /// See [`set_show_text()`][Self::set_show_text()].
    ///
    /// # Returns
    ///
    /// [`true`] if text is shown in the progress bar
    #[doc(alias = "gtk_progress_bar_get_show_text")]
    #[doc(alias = "get_show_text")]
    #[doc(alias = "show-text")]
    pub fn shows_text(&self) -> bool {
        unsafe { from_glib(ffi::gtk_progress_bar_get_show_text(self.to_glib_none().0)) }
    }

    /// Retrieves the text that is displayed with the progress bar.
    ///
    /// The return value is a reference to the text, not a copy of it,
    /// so will become invalid if you change the text in the progress bar.
    ///
    /// # Returns
    ///
    /// the text
    #[doc(alias = "gtk_progress_bar_get_text")]
    #[doc(alias = "get_text")]
    pub fn text(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::gtk_progress_bar_get_text(self.to_glib_none().0)) }
    }

    /// Indicates that some progress has been made, but you don’t know how much.
    ///
    /// Causes the progress bar to enter “activity mode,” where a block
    /// bounces back and forth. Each call to [`pulse()`][Self::pulse()]
    /// causes the block to move by a little bit (the amount of movement
    /// per pulse is determined by [`set_pulse_step()`][Self::set_pulse_step()]).
    #[doc(alias = "gtk_progress_bar_pulse")]
    pub fn pulse(&self) {
        unsafe {
            ffi::gtk_progress_bar_pulse(self.to_glib_none().0);
        }
    }

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

    /// Causes the progress bar to “fill in” the given fraction
    /// of the bar.
    ///
    /// The fraction should be between 0.0 and 1.0, inclusive.
    /// ## `fraction`
    /// fraction of the task that’s been completed
    #[doc(alias = "gtk_progress_bar_set_fraction")]
    #[doc(alias = "fraction")]
    pub fn set_fraction(&self, fraction: f64) {
        unsafe {
            ffi::gtk_progress_bar_set_fraction(self.to_glib_none().0, fraction);
        }
    }

    /// Sets whether the progress bar is inverted.
    ///
    /// Progress bars normally grow from top to bottom or left to right.
    /// Inverted progress bars grow in the opposite direction.
    /// ## `inverted`
    /// [`true`] to invert the progress bar
    #[doc(alias = "gtk_progress_bar_set_inverted")]
    #[doc(alias = "inverted")]
    pub fn set_inverted(&self, inverted: bool) {
        unsafe {
            ffi::gtk_progress_bar_set_inverted(self.to_glib_none().0, inverted.into_glib());
        }
    }

    /// Sets the fraction of total progress bar length to move the
    /// bouncing block.
    ///
    /// The bouncing block is moved when [`pulse()`][Self::pulse()]
    /// is called.
    /// ## `fraction`
    /// fraction between 0.0 and 1.0
    #[doc(alias = "gtk_progress_bar_set_pulse_step")]
    #[doc(alias = "pulse-step")]
    pub fn set_pulse_step(&self, fraction: f64) {
        unsafe {
            ffi::gtk_progress_bar_set_pulse_step(self.to_glib_none().0, fraction);
        }
    }

    /// Sets whether the progress bar will show text next to the bar.
    ///
    /// The shown text is either the value of the [`text`][struct@crate::ProgressBar#text]
    /// property or, if that is [`None`], the [`fraction`][struct@crate::ProgressBar#fraction] value,
    /// as a percentage.
    ///
    /// To make a progress bar that is styled and sized suitably for containing
    /// text (even if the actual text is blank), set [`show-text`][struct@crate::ProgressBar#show-text]
    /// to [`true`] and [`text`][struct@crate::ProgressBar#text] to the empty string (not [`None`]).
    /// ## `show_text`
    /// whether to show text
    #[doc(alias = "gtk_progress_bar_set_show_text")]
    #[doc(alias = "show-text")]
    pub fn set_show_text(&self, show_text: bool) {
        unsafe {
            ffi::gtk_progress_bar_set_show_text(self.to_glib_none().0, show_text.into_glib());
        }
    }

    /// Causes the given @text to appear next to the progress bar.
    ///
    /// If @text is [`None`] and [`show-text`][struct@crate::ProgressBar#show-text] is [`true`],
    /// the current value of [`fraction`][struct@crate::ProgressBar#fraction] will be displayed
    /// as a percentage.
    ///
    /// If @text is non-[`None`] and [`show-text`][struct@crate::ProgressBar#show-text] is [`true`],
    /// the text will be displayed. In this case, it will not display the progress
    /// percentage. If @text is the empty string, the progress bar will still
    /// be styled and sized suitably for containing text, as long as
    /// [`show-text`][struct@crate::ProgressBar#show-text] is [`true`].
    /// ## `text`
    /// a UTF-8 string
    #[doc(alias = "gtk_progress_bar_set_text")]
    #[doc(alias = "text")]
    pub fn set_text(&self, text: Option<&str>) {
        unsafe {
            ffi::gtk_progress_bar_set_text(self.to_glib_none().0, text.to_glib_none().0);
        }
    }

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

    #[doc(alias = "fraction")]
    pub fn connect_fraction_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_fraction_trampoline<F: Fn(&ProgressBar) + 'static>(
            this: *mut ffi::GtkProgressBar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::fraction".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fraction_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "inverted")]
    pub fn connect_inverted_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_inverted_trampoline<F: Fn(&ProgressBar) + 'static>(
            this: *mut ffi::GtkProgressBar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::inverted".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_inverted_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "pulse-step")]
    pub fn connect_pulse_step_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_pulse_step_trampoline<F: Fn(&ProgressBar) + 'static>(
            this: *mut ffi::GtkProgressBar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::pulse-step".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_pulse_step_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

impl Default for ProgressBar {
    fn default() -> Self {
        Self::new()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`ProgressBar`] 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 ProgressBarBuilder {
    builder: glib::object::ObjectBuilder<'static, ProgressBar>,
}

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

    /// The preferred place to ellipsize the string.
    ///
    /// The text will be ellipsized if the progress bar 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 progress bar requests
    /// only enough space to display the ellipsis ("..."). Another means to set a
    /// progress bar's width is [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()].
    pub fn ellipsize(self, ellipsize: pango::EllipsizeMode) -> Self {
        Self {
            builder: self.builder.property("ellipsize", ellipsize),
        }
    }

    /// The fraction of total work that has been completed.
    pub fn fraction(self, fraction: f64) -> Self {
        Self {
            builder: self.builder.property("fraction", fraction),
        }
    }

    /// Invert the direction in which the progress bar grows.
    pub fn inverted(self, inverted: bool) -> Self {
        Self {
            builder: self.builder.property("inverted", inverted),
        }
    }

    /// The fraction of total progress to move the bounding block when pulsed.
    pub fn pulse_step(self, pulse_step: f64) -> Self {
        Self {
            builder: self.builder.property("pulse-step", pulse_step),
        }
    }

    /// Sets whether the progress bar will show a text in addition
    /// to the bar itself.
    ///
    /// The shown text is either the value of the [`text`][struct@crate::ProgressBar#text]
    /// property or, if that is [`None`], the [`fraction`][struct@crate::ProgressBar#fraction]
    /// value, as a percentage.
    ///
    /// To make a progress bar that is styled and sized suitably for showing text
    /// (even if the actual text is blank), set [`show-text`][struct@crate::ProgressBar#show-text]
    /// to [`true`] and [`text`][struct@crate::ProgressBar#text] to the empty string (not [`None`]).
    pub fn show_text(self, show_text: bool) -> Self {
        Self {
            builder: self.builder.property("show-text", show_text),
        }
    }

    /// Text to be displayed in the progress bar.
    pub fn text(self, text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("text", text.into()),
        }
    }

    /// Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    /// Whether the widget can receive pointer events.
    pub fn can_target(self, can_target: bool) -> Self {
        Self {
            builder: self.builder.property("can-target", can_target),
        }
    }

    /// A list of css classes applied to this widget.
    pub fn css_classes(self, css_classes: impl Into<glib::StrV>) -> Self {
        Self {
            builder: self.builder.property("css-classes", css_classes.into()),
        }
    }

    /// The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn css_name(self, css_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("css-name", css_name.into()),
        }
    }

    /// The cursor used by @widget.
    pub fn cursor(self, cursor: &gdk::Cursor) -> Self {
        Self {
            builder: self.builder.property("cursor", cursor.clone()),
        }
    }

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// Whether this widget itself will accept the input focus.
    pub fn focusable(self, focusable: bool) -> Self {
        Self {
            builder: self.builder.property("focusable", focusable),
        }
    }

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

    /// Enables or disables the emission of the [`query-tooltip`][struct@crate::Widget#query-tooltip]
    /// signal on @widget.
    ///
    /// A true value indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    /// Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally.
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the `hexpand` property.
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    /// The [`LayoutManager`][crate::LayoutManager] instance to use to compute
    /// the preferred size of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn layout_manager(self, layout_manager: &impl IsA<LayoutManager>) -> Self {
        Self {
            builder: self
                .builder
                .property("layout-manager", layout_manager.clone().upcast()),
        }
    }

    /// Makes this widget act like a modal dialog, with respect to
    /// event delivery.
    ///
    /// Global event controllers will not handle events with targets
    /// inside the widget, unless they are set up to ignore propagation
    /// limits. See [`EventControllerExt::set_propagation_limit()`][crate::prelude::EventControllerExt::set_propagation_limit()].
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    pub fn limit_events(self, limit_events: bool) -> Self {
        Self {
            builder: self.builder.property("limit-events", limit_events),
        }
    }

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

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

    /// The requested opacity of the widget.
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    /// How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn overflow(self, overflow: Overflow) -> Self {
        Self {
            builder: self.builder.property("overflow", overflow),
        }
    }

    /// Whether the widget will receive the default action when it is focused.
    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    /// Whether the widget responds to input.
    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 Pango markup.
    ///
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    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 `NULL`:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    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.
    pub fn valign(self, valign: Align) -> Self {
        Self {
            builder: self.builder.property("valign", valign),
        }
    }

    /// Whether to expand vertically.
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the `vexpand` property.
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    /// Whether the widget is visible.
    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    /// Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    /// The accessible role of the given [`Accessible`][crate::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    pub fn accessible_role(self, accessible_role: AccessibleRole) -> Self {
        Self {
            builder: self.builder.property("accessible-role", accessible_role),
        }
    }

    /// The orientation of the orientable.
    pub fn orientation(self, orientation: Orientation) -> Self {
        Self {
            builder: self.builder.property("orientation", orientation),
        }
    }

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