#[cfg(feature = "v1_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
use crate::CssClassBinding;
use crate::ffi;
use glib::{prelude::*, translate::*};
#[cfg(feature = "v1_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
use std::boxed::Box as Box_;
#[cfg(feature = "v1_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
#[doc(alias = "adw_bind_property_to_css_class")]
pub fn bind_property_to_css_class(
source: &impl IsA<glib::Object>,
source_property: &str,
target: &impl IsA<gtk::Widget>,
target_css_class: &str,
flags: glib::BindingFlags,
) -> CssClassBinding {
assert_initialized_main_thread!();
unsafe {
from_glib_none(ffi::adw_bind_property_to_css_class(
source.as_ref().to_glib_none().0,
source_property.to_glib_none().0,
target.as_ref().to_glib_none().0,
target_css_class.to_glib_none().0,
flags.into_glib(),
))
}
}
#[cfg(feature = "v1_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
#[doc(alias = "adw_bind_property_to_css_class_full")]
pub fn bind_property_to_css_class_full(
source: &impl IsA<glib::Object>,
source_property: &str,
target: &impl IsA<gtk::Widget>,
target_css_class: &str,
flags: glib::BindingFlags,
map_to_class: Option<Box_<dyn Fn(&CssClassBinding, &glib::Value) -> bool + 'static>>,
map_to_property: Option<Box_<dyn Fn(&CssClassBinding, bool, &glib::Value) + 'static>>,
) -> CssClassBinding {
assert_initialized_main_thread!();
let map_to_class_data: Option<Box_<dyn Fn(&CssClassBinding, &glib::Value) -> bool + 'static>> =
map_to_class;
unsafe extern "C" fn map_to_class_func(
self_: *mut ffi::AdwCssClassBinding,
property_value: *const glib::gobject_ffi::GValue,
user_data: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
unsafe {
let self_ = from_glib_borrow(self_);
let property_value = from_glib_borrow(property_value);
let callback: &(
Option<Box_<dyn Fn(&CssClassBinding, &glib::Value) -> bool + 'static>>,
Option<Box_<dyn Fn(&CssClassBinding, bool, &glib::Value) + 'static>>,
) = &*(user_data as *mut _);
if let Some(ref callback) = callback.0 {
callback(&self_, &property_value)
} else {
panic!("cannot get closure...")
}
.into_glib()
}
}
let map_to_class = if map_to_class_data.is_some() {
Some(map_to_class_func as _)
} else {
None
};
let map_to_property_data: Option<Box_<dyn Fn(&CssClassBinding, bool, &glib::Value) + 'static>> =
map_to_property;
unsafe extern "C" fn map_to_property_func(
self_: *mut ffi::AdwCssClassBinding,
class_applied: glib::ffi::gboolean,
property_value: *mut glib::gobject_ffi::GValue,
user_data: glib::ffi::gpointer,
) {
unsafe {
let self_ = from_glib_borrow(self_);
let class_applied = from_glib(class_applied);
let property_value = from_glib_borrow(property_value);
let callback: &(
Option<Box_<dyn Fn(&CssClassBinding, &glib::Value) -> bool + 'static>>,
Option<Box_<dyn Fn(&CssClassBinding, bool, &glib::Value) + 'static>>,
) = &*(user_data as *mut _);
if let Some(ref callback) = callback.1 {
callback(&self_, class_applied, &property_value)
} else {
panic!("cannot get closure...")
}
}
}
let map_to_property = if map_to_property_data.is_some() {
Some(map_to_property_func as _)
} else {
None
};
unsafe extern "C" fn notify_func(data: glib::ffi::gpointer) {
unsafe {
let _callback: Box_<(
Option<Box_<dyn Fn(&CssClassBinding, &glib::Value) -> bool + 'static>>,
Option<Box_<dyn Fn(&CssClassBinding, bool, &glib::Value) + 'static>>,
)> = Box_::from_raw(data as *mut _);
}
}
let destroy_call8 = Some(notify_func as _);
let super_callback0: Box_<(
Option<Box_<dyn Fn(&CssClassBinding, &glib::Value) -> bool + 'static>>,
Option<Box_<dyn Fn(&CssClassBinding, bool, &glib::Value) + 'static>>,
)> = Box_::new((map_to_class_data, map_to_property_data));
unsafe {
from_glib_none(ffi::adw_bind_property_to_css_class_full(
source.as_ref().to_glib_none().0,
source_property.to_glib_none().0,
target.as_ref().to_glib_none().0,
target_css_class.to_glib_none().0,
flags.into_glib(),
map_to_class,
map_to_property,
Box_::into_raw(super_callback0) as *mut _,
destroy_call8,
))
}
}
#[doc(alias = "adw_get_enable_animations")]
#[doc(alias = "get_enable_animations")]
pub fn is_animations_enabled(widget: &impl IsA<gtk::Widget>) -> bool {
assert_initialized_main_thread!();
unsafe {
from_glib(ffi::adw_get_enable_animations(
widget.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "adw_get_major_version")]
#[doc(alias = "get_major_version")]
pub fn major_version() -> u32 {
assert_initialized_main_thread!();
unsafe { ffi::adw_get_major_version() }
}
#[doc(alias = "adw_get_micro_version")]
#[doc(alias = "get_micro_version")]
pub fn micro_version() -> u32 {
assert_initialized_main_thread!();
unsafe { ffi::adw_get_micro_version() }
}
#[doc(alias = "adw_get_minor_version")]
#[doc(alias = "get_minor_version")]
pub fn minor_version() -> u32 {
assert_initialized_main_thread!();
unsafe { ffi::adw_get_minor_version() }
}
#[doc(alias = "adw_is_initialized")]
pub fn is_initialized() -> bool {
assert_initialized_main_thread!();
unsafe { from_glib(ffi::adw_is_initialized()) }
}
#[doc(alias = "adw_lerp")]
pub fn lerp(a: f64, b: f64, t: f64) -> f64 {
assert_initialized_main_thread!();
unsafe { ffi::adw_lerp(a, b, t) }
}
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
#[doc(alias = "adw_rgba_to_standalone")]
pub fn rgba_to_standalone(rgba: &gdk::RGBA, dark: bool) -> gdk::RGBA {
assert_initialized_main_thread!();
unsafe {
let mut standalone_rgba = gdk::RGBA::uninitialized();
ffi::adw_rgba_to_standalone(
rgba.to_glib_none().0,
dark.into_glib(),
standalone_rgba.to_glib_none_mut().0,
);
standalone_rgba
}
}