atk/auto/

value.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::{Range, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// /refsect1
    ///
    /// ## Signals
    ///
    ///
    /// #### `value-changed`
    ///  The 'value-changed' signal is emitted when the current value
    /// that represent the object changes. `value` is the numerical
    /// representation of this new value. `text` is the human
    /// readable text alternative of `value`, and can be NULL if it is
    /// not available. Note that if there is a textual description
    /// associated with the new numeric value, that description
    /// should be included regardless of whether or not it has also
    /// changed.
    ///
    /// Example: a password meter whose value changes as the user
    /// types their new password. Appropiate value text would be
    /// "weak", "acceptable" and "strong".
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`ValueExt`][trait@crate::prelude::ValueExt]
    #[doc(alias = "AtkValue")]
    pub struct Value(Interface<ffi::AtkValue, ffi::AtkValueIface>);

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

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

/// Trait containing all [`struct@Value`] methods.
///
/// # Implementors
///
/// [`NoOpObject`][struct@crate::NoOpObject], [`Value`][struct@crate::Value]
pub trait ValueExt: IsA<Value> + 'static {
    /// Gets the value of this object.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`value_and_text()`][Self::value_and_text()]
    /// instead.
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// a [`glib::Value`][crate::glib::Value] representing the current accessible value
    #[doc(alias = "atk_value_get_current_value")]
    #[doc(alias = "get_current_value")]
    fn current_value(&self) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::atk_value_get_current_value(
                self.as_ref().to_glib_none().0,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    /// Gets the minimum increment by which the value of this object may be
    /// changed. If zero, the minimum increment is undefined, which may
    /// mean that it is limited only by the floating point precision of the
    /// platform.
    ///
    /// # Returns
    ///
    /// the minimum increment by which the value of this
    /// object may be changed. zero if undefined.
    #[doc(alias = "atk_value_get_increment")]
    #[doc(alias = "get_increment")]
    fn increment(&self) -> f64 {
        unsafe { ffi::atk_value_get_increment(self.as_ref().to_glib_none().0) }
    }

    /// Gets the maximum value of this object.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`range()`][Self::range()] instead.
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// a [`glib::Value`][crate::glib::Value] representing the maximum accessible value
    #[doc(alias = "atk_value_get_maximum_value")]
    #[doc(alias = "get_maximum_value")]
    fn maximum_value(&self) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::atk_value_get_maximum_value(
                self.as_ref().to_glib_none().0,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    /// Gets the minimum increment by which the value of this object may be changed. If zero,
    /// the minimum increment is undefined, which may mean that it is limited only by the
    /// floating point precision of the platform.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`increment()`][Self::increment()] instead.
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// a [`glib::Value`][crate::glib::Value] representing the minimum increment by which the accessible value may be changed
    #[doc(alias = "atk_value_get_minimum_increment")]
    #[doc(alias = "get_minimum_increment")]
    fn minimum_increment(&self) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::atk_value_get_minimum_increment(
                self.as_ref().to_glib_none().0,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    /// Gets the minimum value of this object.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`range()`][Self::range()] instead.
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// a [`glib::Value`][crate::glib::Value] representing the minimum accessible value
    #[doc(alias = "atk_value_get_minimum_value")]
    #[doc(alias = "get_minimum_value")]
    fn minimum_value(&self) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::atk_value_get_minimum_value(
                self.as_ref().to_glib_none().0,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    /// Gets the range of this object.
    ///
    /// # Returns
    ///
    /// a newly allocated [`Range`][crate::Range]
    /// that represents the minimum, maximum and descriptor (if available)
    /// of `self`. NULL if that range is not defined.
    #[doc(alias = "atk_value_get_range")]
    #[doc(alias = "get_range")]
    fn range(&self) -> Option<Range> {
        unsafe { from_glib_full(ffi::atk_value_get_range(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the list of subranges defined for this object. See [`Value`][crate::Value]
    /// introduction for examples of subranges and when to expose them.
    ///
    /// # Returns
    ///
    /// an `GSList` of
    /// [`Range`][crate::Range] which each of the subranges defined for this object. Free
    /// the returns list with `g_slist_free()`.
    #[doc(alias = "atk_value_get_sub_ranges")]
    #[doc(alias = "get_sub_ranges")]
    fn sub_ranges(&self) -> Vec<Range> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::atk_value_get_sub_ranges(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current value and the human readable text alternative of
    /// `self`. `text` is a newly created string, that must be freed by the
    /// caller. Can be NULL if no descriptor is available.
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// address of `gdouble` to put the current value of `self`
    ///
    /// ## `text`
    /// address of `gchar` to put the human
    /// readable text alternative for `value`
    #[doc(alias = "atk_value_get_value_and_text")]
    #[doc(alias = "get_value_and_text")]
    fn value_and_text(&self) -> (f64, glib::GString) {
        unsafe {
            let mut value = std::mem::MaybeUninit::uninit();
            let mut text = std::ptr::null_mut();
            ffi::atk_value_get_value_and_text(
                self.as_ref().to_glib_none().0,
                value.as_mut_ptr(),
                &mut text,
            );
            (value.assume_init(), from_glib_full(text))
        }
    }

    /// Sets the value of this object.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`set_value()`][Self::set_value()] instead.
    /// ## `value`
    /// a [`glib::Value`][crate::glib::Value] which is the desired new accessible value.
    ///
    /// # Returns
    ///
    /// [`true`] if new value is successfully set, [`false`] otherwise.
    #[doc(alias = "atk_value_set_current_value")]
    fn set_current_value(&self, value: &glib::Value) -> bool {
        unsafe {
            from_glib(ffi::atk_value_set_current_value(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
            ))
        }
    }

    /// Sets the value of this object.
    ///
    /// This method is intended to provide a way to change the value of the
    /// object. In any case, it is possible that the value can't be
    /// modified (ie: a read-only component). If the value changes due this
    /// call, it is possible that the text could change, and will trigger
    /// an [`value-changed`][struct@crate::Value#value-changed] signal emission.
    ///
    /// Note for implementors: the deprecated [`set_current_value()`][Self::set_current_value()]
    /// method returned TRUE or FALSE depending if the value was assigned
    /// or not. In the practice several implementors were not able to
    /// decide it, and returned TRUE in any case. For that reason it is not
    /// required anymore to return if the value was properly assigned or
    /// not.
    /// ## `new_value`
    /// a double which is the desired new accessible value.
    #[doc(alias = "atk_value_set_value")]
    fn set_value(&self, new_value: f64) {
        unsafe {
            ffi::atk_value_set_value(self.as_ref().to_glib_none().0, new_value);
        }
    }

    /// The 'value-changed' signal is emitted when the current value
    /// that represent the object changes. `value` is the numerical
    /// representation of this new value. `text` is the human
    /// readable text alternative of `value`, and can be NULL if it is
    /// not available. Note that if there is a textual description
    /// associated with the new numeric value, that description
    /// should be included regardless of whether or not it has also
    /// changed.
    ///
    /// Example: a password meter whose value changes as the user
    /// types their new password. Appropiate value text would be
    /// "weak", "acceptable" and "strong".
    /// ## `value`
    /// the new value in a numerical form.
    /// ## `text`
    /// human readable text alternative (also called
    /// description) of this object. NULL if not available.
    #[doc(alias = "value-changed")]
    fn connect_value_changed<F: Fn(&Self, f64, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn value_changed_trampoline<
            P: IsA<Value>,
            F: Fn(&P, f64, &str) + 'static,
        >(
            this: *mut ffi::AtkValue,
            value: std::ffi::c_double,
            text: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Value::from_glib_borrow(this).unsafe_cast_ref(),
                    value,
                    &glib::GString::from_glib_borrow(text),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"value-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    value_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Value>> ValueExt for O {}