gtk4/auto/

scale.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::{
    ffi, Accessible, AccessibleRole, Adjustment, Align, Buildable, ConstraintTarget, LayoutManager,
    Orientable, Orientation, Overflow, PositionType, Range, Widget,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
glib::wrapper! {
    /// Allows to select a numeric value with a slider control.
    ///
    /// <picture>
    ///   <source srcset="scales-dark.png" media="(prefers-color-scheme: dark)">
    ///   <img alt="An example GtkScale" src="scales.png">
    /// </picture>
    ///
    /// To use it, you’ll probably want to investigate the methods on its base
    /// class, [`Range`][crate::Range], in addition to the methods for [`Scale`][crate::Scale] itself.
    /// To set the value of a scale, you would normally use [`RangeExt::set_value()`][crate::prelude::RangeExt::set_value()].
    /// To detect changes to the value, you would normally use the
    /// [`value-changed`][struct@crate::Range#value-changed] signal.
    ///
    /// Note that using the same upper and lower bounds for the [`Scale`][crate::Scale] (through
    /// the [`Range`][crate::Range] methods) will hide the slider itself. This is useful for
    /// applications that want to show an undeterminate value on the scale, without
    /// changing the layout of the application (such as movie or music players).
    ///
    /// # GtkScale as GtkBuildable
    ///
    /// [`Scale`][crate::Scale] supports a custom `<marks>` element, which can contain multiple
    /// `<mark\>` elements. The “value” and “position” attributes have the same
    /// meaning as [`ScaleExt::add_mark()`][crate::prelude::ScaleExt::add_mark()] parameters of the same name. If
    /// the element is not empty, its content is taken as the markup to show at
    /// the mark. It can be translated with the usual ”translatable” and
    /// “context” attributes.
    ///
    /// # Shortcuts and Gestures
    ///
    /// [`PopoverMenu`][crate::PopoverMenu] supports the following keyboard shortcuts:
    ///
    /// - Arrow keys, <kbd>+</kbd> and <kbd>-</kbd> will increment or decrement
    ///   by step, or by page when combined with <kbd>Ctrl</kbd>.
    /// - <kbd>PgUp</kbd> and <kbd>PgDn</kbd> will increment or decrement by page.
    /// - <kbd>Home</kbd> and <kbd>End</kbd> will set the minimum or maximum value.
    ///
    /// # CSS nodes
    ///
    /// ```text
    /// scale[.fine-tune][.marks-before][.marks-after]
    /// ├── [value][.top][.right][.bottom][.left]
    /// ├── marks.top
    /// │   ├── mark
    /// │   ┊    ├── [label]
    /// │   ┊    ╰── indicator
    /// ┊   ┊
    /// │   ╰── mark
    /// ├── marks.bottom
    /// │   ├── mark
    /// │   ┊    ├── indicator
    /// │   ┊    ╰── [label]
    /// ┊   ┊
    /// │   ╰── mark
    /// ╰── trough
    ///     ├── [fill]
    ///     ├── [highlight]
    ///     ╰── slider
    /// ```
    ///
    /// [`Scale`][crate::Scale] has a main CSS node with name scale and a subnode for its contents,
    /// with subnodes named trough and slider.
    ///
    /// The main node gets the style class .fine-tune added when the scale is in
    /// 'fine-tuning' mode.
    ///
    /// If the scale has an origin (see [`ScaleExt::set_has_origin()`][crate::prelude::ScaleExt::set_has_origin()]), there is
    /// a subnode with name highlight below the trough node that is used for rendering
    /// the highlighted part of the trough.
    ///
    /// If the scale is showing a fill level (see [`RangeExt::set_show_fill_level()`][crate::prelude::RangeExt::set_show_fill_level()]),
    /// there is a subnode with name fill below the trough node that is used for
    /// rendering the filled in part of the trough.
    ///
    /// If marks are present, there is a marks subnode before or after the trough
    /// node, below which each mark gets a node with name mark. The marks nodes get
    /// either the .top or .bottom style class.
    ///
    /// The mark node has a subnode named indicator. If the mark has text, it also
    /// has a subnode named label. When the mark is either above or left of the
    /// scale, the label subnode is the first when present. Otherwise, the indicator
    /// subnode is the first.
    ///
    /// The main CSS node gets the 'marks-before' and/or 'marks-after' style classes
    /// added depending on what marks are present.
    ///
    /// If the scale is displaying the value (see [`draw-value`][struct@crate::Scale#draw-value]),
    /// there is subnode with name value. This node will get the .top or .bottom style
    /// classes similar to the marks node.
    ///
    /// # Accessibility
    ///
    /// [`Scale`][crate::Scale] uses the [enum@Gtk.AccessibleRole.slider] role.
    ///
    /// ## Properties
    ///
    ///
    /// #### `digits`
    ///  The number of decimal places that are displayed in the value.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `draw-value`
    ///  Whether the current value is displayed as a string next to the slider.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-origin`
    ///  Whether the scale has an origin.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `value-pos`
    ///  The position in which the current value is displayed.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Range</h4></summary>
    ///
    ///
    /// #### `adjustment`
    ///  The adjustment that is controlled by the range.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `fill-level`
    ///  The fill level (e.g. prebuffering of a network stream).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `inverted`
    ///  If [`true`], the direction in which the slider moves is inverted.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `restrict-to-fill-level`
    ///  Controls whether slider movement is restricted to an
    /// upper boundary set by the fill level.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `round-digits`
    ///  The number of digits to round the value to when
    /// it changes.
    ///
    /// See [`change-value`][struct@crate::Range#change-value].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `show-fill-level`
    ///  Controls whether fill level indicator graphics are displayed
    /// on the trough.
    ///
    /// Readable | Writeable
    /// </details>
    /// <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
    ///
    /// [`ScaleExt`][trait@crate::prelude::ScaleExt], [`RangeExt`][trait@crate::prelude::RangeExt], [`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], [`ScaleExtManual`][trait@crate::prelude::ScaleExtManual], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkScale")]
    pub struct Scale(Object<ffi::GtkScale, ffi::GtkScaleClass>) @extends Range, Widget, @implements Accessible, Buildable, ConstraintTarget, AccessibleRange, Orientable;

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

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

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

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

    /// Creates a new [`Scale`][crate::Scale].
    /// ## `orientation`
    /// the scale’s orientation.
    /// ## `adjustment`
    /// the [`Adjustment`][crate::Adjustment] which sets
    ///   the range of the scale, or [`None`] to create a new adjustment.
    ///
    /// # Returns
    ///
    /// a new [`Scale`][crate::Scale]
    #[doc(alias = "gtk_scale_new")]
    pub fn new(orientation: Orientation, adjustment: Option<&impl IsA<Adjustment>>) -> Scale {
        assert_initialized_main_thread!();
        unsafe {
            Widget::from_glib_none(ffi::gtk_scale_new(
                orientation.into_glib(),
                adjustment.map(|p| p.as_ref()).to_glib_none().0,
            ))
            .unsafe_cast()
        }
    }

    /// Creates a new scale widget with a range from @min to @max.
    ///
    /// The returns scale will have the given orientation and will let the
    /// user input a number between @min and @max (including @min and @max)
    /// with the increment @step. @step must be nonzero; it’s the distance
    /// the slider moves when using the arrow keys to adjust the scale
    /// value.
    ///
    /// Note that the way in which the precision is derived works best if
    /// @step is a power of ten. If the resulting precision is not suitable
    /// for your needs, use [`ScaleExt::set_digits()`][crate::prelude::ScaleExt::set_digits()] to correct it.
    /// ## `orientation`
    /// the scale’s orientation.
    /// ## `min`
    /// minimum value
    /// ## `max`
    /// maximum value
    /// ## `step`
    /// step increment (tick size) used with keyboard shortcuts
    ///
    /// # Returns
    ///
    /// a new [`Scale`][crate::Scale]
    #[doc(alias = "gtk_scale_new_with_range")]
    #[doc(alias = "new_with_range")]
    pub fn with_range(orientation: Orientation, min: f64, max: f64, step: f64) -> Scale {
        assert_initialized_main_thread!();
        unsafe {
            Widget::from_glib_none(ffi::gtk_scale_new_with_range(
                orientation.into_glib(),
                min,
                max,
                step,
            ))
            .unsafe_cast()
        }
    }

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

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

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

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

    /// The number of decimal places that are displayed in the value.
    pub fn digits(self, digits: i32) -> Self {
        Self {
            builder: self.builder.property("digits", digits),
        }
    }

    /// Whether the current value is displayed as a string next to the slider.
    pub fn draw_value(self, draw_value: bool) -> Self {
        Self {
            builder: self.builder.property("draw-value", draw_value),
        }
    }

    /// Whether the scale has an origin.
    pub fn has_origin(self, has_origin: bool) -> Self {
        Self {
            builder: self.builder.property("has-origin", has_origin),
        }
    }

    /// The position in which the current value is displayed.
    pub fn value_pos(self, value_pos: PositionType) -> Self {
        Self {
            builder: self.builder.property("value-pos", value_pos),
        }
    }

    /// The adjustment that is controlled by the range.
    pub fn adjustment(self, adjustment: &impl IsA<Adjustment>) -> Self {
        Self {
            builder: self
                .builder
                .property("adjustment", adjustment.clone().upcast()),
        }
    }

    /// The fill level (e.g. prebuffering of a network stream).
    pub fn fill_level(self, fill_level: f64) -> Self {
        Self {
            builder: self.builder.property("fill-level", fill_level),
        }
    }

    /// If [`true`], the direction in which the slider moves is inverted.
    pub fn inverted(self, inverted: bool) -> Self {
        Self {
            builder: self.builder.property("inverted", inverted),
        }
    }

    /// Controls whether slider movement is restricted to an
    /// upper boundary set by the fill level.
    pub fn restrict_to_fill_level(self, restrict_to_fill_level: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("restrict-to-fill-level", restrict_to_fill_level),
        }
    }

    /// The number of digits to round the value to when
    /// it changes.
    ///
    /// See [`change-value`][struct@crate::Range#change-value].
    pub fn round_digits(self, round_digits: i32) -> Self {
        Self {
            builder: self.builder.property("round-digits", round_digits),
        }
    }

    /// Controls whether fill level indicator graphics are displayed
    /// on the trough.
    pub fn show_fill_level(self, show_fill_level: bool) -> Self {
        Self {
            builder: self.builder.property("show-fill-level", show_fill_level),
        }
    }

    /// 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 [`Scale`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Scale {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}

/// Trait containing all [`struct@Scale`] methods.
///
/// # Implementors
///
/// [`Scale`][struct@crate::Scale]
pub trait ScaleExt: IsA<Scale> + 'static {
    /// Adds a mark at @value.
    ///
    /// A mark is indicated visually by drawing a tick mark next to the scale,
    /// and GTK makes it easy for the user to position the scale exactly at the
    /// marks value.
    ///
    /// If @markup is not [`None`], text is shown next to the tick mark.
    ///
    /// To remove marks from a scale, use [`clear_marks()`][Self::clear_marks()].
    /// ## `value`
    /// the value at which the mark is placed, must be between
    ///   the lower and upper limits of the scales’ adjustment
    /// ## `position`
    /// where to draw the mark. For a horizontal scale, [`PositionType::Top`][crate::PositionType::Top]
    ///   and [`PositionType::Left`][crate::PositionType::Left] are drawn above the scale, anything else below.
    ///   For a vertical scale, [`PositionType::Left`][crate::PositionType::Left] and [`PositionType::Top`][crate::PositionType::Top] are drawn to
    ///   the left of the scale, anything else to the right.
    /// ## `markup`
    /// Text to be shown at the mark, using Pango markup
    #[doc(alias = "gtk_scale_add_mark")]
    fn add_mark(&self, value: f64, position: PositionType, markup: Option<&str>) {
        unsafe {
            ffi::gtk_scale_add_mark(
                self.as_ref().to_glib_none().0,
                value,
                position.into_glib(),
                markup.to_glib_none().0,
            );
        }
    }

    /// Removes any marks that have been added.
    #[doc(alias = "gtk_scale_clear_marks")]
    fn clear_marks(&self) {
        unsafe {
            ffi::gtk_scale_clear_marks(self.as_ref().to_glib_none().0);
        }
    }

    /// Gets the number of decimal places that are displayed in the value.
    ///
    /// # Returns
    ///
    /// the number of decimal places that are displayed
    #[doc(alias = "gtk_scale_get_digits")]
    #[doc(alias = "get_digits")]
    fn digits(&self) -> i32 {
        unsafe { ffi::gtk_scale_get_digits(self.as_ref().to_glib_none().0) }
    }

    /// Returns whether the current value is displayed as a string
    /// next to the slider.
    ///
    /// # Returns
    ///
    /// whether the current value is displayed as a string
    #[doc(alias = "gtk_scale_get_draw_value")]
    #[doc(alias = "get_draw_value")]
    #[doc(alias = "draw-value")]
    fn draws_value(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_scale_get_draw_value(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the scale has an origin.
    ///
    /// # Returns
    ///
    /// [`true`] if the scale has an origin.
    #[doc(alias = "gtk_scale_get_has_origin")]
    #[doc(alias = "get_has_origin")]
    #[doc(alias = "has-origin")]
    fn has_origin(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_scale_get_has_origin(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`pango::Layout`][crate::pango::Layout] used to display the scale.
    ///
    /// The returned object is owned by the scale so does not need
    /// to be freed by the caller.
    ///
    /// # Returns
    ///
    /// the [`pango::Layout`][crate::pango::Layout]
    ///   for this scale, or [`None`] if the [`draw-value`][struct@crate::Scale#draw-value]
    ///   property is [`false`].
    #[doc(alias = "gtk_scale_get_layout")]
    #[doc(alias = "get_layout")]
    fn layout(&self) -> Option<pango::Layout> {
        unsafe { from_glib_none(ffi::gtk_scale_get_layout(self.as_ref().to_glib_none().0)) }
    }

    /// Obtains the coordinates where the scale will draw the
    /// [`pango::Layout`][crate::pango::Layout] representing the text in the scale.
    ///
    /// Remember when using the [`pango::Layout`][crate::pango::Layout] function you need to
    /// convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
    ///
    /// If the [`draw-value`][struct@crate::Scale#draw-value] property is [`false`], the return
    /// values are undefined.
    ///
    /// # Returns
    ///
    ///
    /// ## `x`
    /// location to store X offset of layout
    ///
    /// ## `y`
    /// location to store Y offset of layout
    #[doc(alias = "gtk_scale_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_scale_get_layout_offsets(
                self.as_ref().to_glib_none().0,
                x.as_mut_ptr(),
                y.as_mut_ptr(),
            );
            (x.assume_init(), y.assume_init())
        }
    }

    /// Gets the position in which the current value is displayed.
    ///
    /// # Returns
    ///
    /// the position in which the current value is displayed
    #[doc(alias = "gtk_scale_get_value_pos")]
    #[doc(alias = "get_value_pos")]
    #[doc(alias = "value-pos")]
    fn value_pos(&self) -> PositionType {
        unsafe { from_glib(ffi::gtk_scale_get_value_pos(self.as_ref().to_glib_none().0)) }
    }

    /// Sets the number of decimal places that are displayed in the value.
    ///
    /// Also causes the value of the adjustment to be rounded to this number
    /// of digits, so the retrieved value matches the displayed one, if
    /// [`draw-value`][struct@crate::Scale#draw-value] is [`true`] when the value changes. If
    /// you want to enforce rounding the value when [`draw-value`][struct@crate::Scale#draw-value]
    /// is [`false`], you can set [`round-digits`][struct@crate::Range#round-digits] instead.
    ///
    /// Note that rounding to a small number of digits can interfere with
    /// the smooth autoscrolling that is built into [`Scale`][crate::Scale]. As an alternative,
    /// you can use [`set_format_value_func()`][Self::set_format_value_func()] to format the displayed
    /// value yourself.
    /// ## `digits`
    /// the number of decimal places to display,
    ///   e.g. use 1 to display 1.0, 2 to display 1.00, etc
    #[doc(alias = "gtk_scale_set_digits")]
    #[doc(alias = "digits")]
    fn set_digits(&self, digits: i32) {
        unsafe {
            ffi::gtk_scale_set_digits(self.as_ref().to_glib_none().0, digits);
        }
    }

    /// Specifies whether the current value is displayed as a string next
    /// to the slider.
    /// ## `draw_value`
    /// [`true`] to draw the value
    #[doc(alias = "gtk_scale_set_draw_value")]
    #[doc(alias = "draw-value")]
    fn set_draw_value(&self, draw_value: bool) {
        unsafe {
            ffi::gtk_scale_set_draw_value(self.as_ref().to_glib_none().0, draw_value.into_glib());
        }
    }

    /// @func allows you to change how the scale value is displayed.
    ///
    /// The given function will return an allocated string representing
    /// @value. That string will then be used to display the scale's value.
    ///
    /// If #NULL is passed as @func, the value will be displayed on
    /// its own, rounded according to the value of the
    /// [`digits`][struct@crate::Scale#digits] property.
    /// ## `func`
    /// function
    ///   that formats the value
    /// ## `destroy_notify`
    /// destroy function for @user_data
    #[doc(alias = "gtk_scale_set_format_value_func")]
    fn set_format_value_func<P: Fn(&Scale, f64) -> String + 'static>(&self, func: P) {
        let func_data: Box_<P> = Box_::new(func);
        unsafe extern "C" fn func_func<P: Fn(&Scale, f64) -> String + 'static>(
            scale: *mut ffi::GtkScale,
            value: std::ffi::c_double,
            user_data: glib::ffi::gpointer,
        ) -> *mut std::ffi::c_char {
            let scale = from_glib_borrow(scale);
            let callback = &*(user_data as *mut P);
            (*callback)(&scale, value).to_glib_full()
        }
        let func = Some(func_func::<P> as _);
        unsafe extern "C" fn destroy_notify_func<P: Fn(&Scale, f64) -> String + 'static>(
            data: glib::ffi::gpointer,
        ) {
            let _callback = Box_::from_raw(data as *mut P);
        }
        let destroy_call3 = Some(destroy_notify_func::<P> as _);
        let super_callback0: Box_<P> = func_data;
        unsafe {
            ffi::gtk_scale_set_format_value_func(
                self.as_ref().to_glib_none().0,
                func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Sets whether the scale has an origin.
    ///
    /// If [`has-origin`][struct@crate::Scale#has-origin] is set to [`true`] (the default),
    /// the scale will highlight the part of the trough between the origin
    /// (bottom or left side) and the current value.
    /// ## `has_origin`
    /// [`true`] if the scale has an origin
    #[doc(alias = "gtk_scale_set_has_origin")]
    #[doc(alias = "has-origin")]
    fn set_has_origin(&self, has_origin: bool) {
        unsafe {
            ffi::gtk_scale_set_has_origin(self.as_ref().to_glib_none().0, has_origin.into_glib());
        }
    }

    /// Sets the position in which the current value is displayed.
    /// ## `pos`
    /// the position in which the current value is displayed
    #[doc(alias = "gtk_scale_set_value_pos")]
    #[doc(alias = "value-pos")]
    fn set_value_pos(&self, pos: PositionType) {
        unsafe {
            ffi::gtk_scale_set_value_pos(self.as_ref().to_glib_none().0, pos.into_glib());
        }
    }

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

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

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

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

impl<O: IsA<Scale>> ScaleExt for O {}