gtk4/auto/map_list_model.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
// 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::ffi;
#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
use crate::SectionModel;
use glib::{
prelude::*,
signal::{connect_raw, SignalHandlerId},
translate::*,
};
use std::boxed::Box as Box_;
#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
glib::wrapper! {
/// A [`MapListModel`][crate::MapListModel] maps the items in a list model to different items.
///
/// [`MapListModel`][crate::MapListModel] uses a `callback::Gtk::MapListModelMapFunc.
///
/// Example: Create a list of `GtkEventControllers`
/// **⚠️ The following code is in c ⚠️**
///
/// ```c
/// static gpointer
/// map_to_controllers (gpointer widget,
/// gpointer data)
/// {
/// gpointer result = gtk_widget_observe_controllers (widget);
/// g_object_unref (widget);
/// return result;
/// }
///
/// widgets = gtk_widget_observe_children (widget);
///
/// controllers = gtk_map_list_model_new (widgets,
/// map_to_controllers,
/// NULL, NULL);
///
/// model = gtk_flatten_list_model_new (GTK_TYPE_EVENT_CONTROLLER,
/// controllers);
/// ```
///
/// [`MapListModel`][crate::MapListModel] will attempt to discard the mapped objects as soon as
/// they are no longer needed and recreate them if necessary.
///
/// [`MapListModel`][crate::MapListModel] passes through sections from the underlying model.
///
/// ## Properties
///
///
/// #### `has-map`
/// If a map is set for this model
///
/// Readable
///
///
/// #### `item-type`
/// The type of items. See [`ListModelExtManual::item_type()`][crate::gio::prelude::ListModelExtManual::item_type()].
///
/// Readable
///
///
/// #### `model`
/// The model being mapped.
///
/// Readable | Writeable | Construct Only
///
///
/// #### `n-items`
/// The number of items. See [`ListModelExtManual::n_items()`][crate::gio::prelude::ListModelExtManual::n_items()].
///
/// Readable
///
/// # Implements
///
/// [`trait@glib::ObjectExt`], [`trait@gio::prelude::ListModelExt`], [`SectionModelExt`][trait@crate::prelude::SectionModelExt]
#[doc(alias = "GtkMapListModel")]
pub struct MapListModel(Object<ffi::GtkMapListModel, ffi::GtkMapListModelClass>) @implements gio::ListModel, SectionModel;
match fn {
type_ => || ffi::gtk_map_list_model_get_type(),
}
}
#[cfg(not(any(feature = "v4_12")))]
glib::wrapper! {
#[doc(alias = "GtkMapListModel")]
pub struct MapListModel(Object<ffi::GtkMapListModel, ffi::GtkMapListModelClass>) @implements gio::ListModel;
match fn {
type_ => || ffi::gtk_map_list_model_get_type(),
}
}
impl MapListModel {
/// Creates a new [`MapListModel`][crate::MapListModel] for the given arguments.
/// ## `model`
/// The model to map
/// ## `map_func`
/// map function
///
/// # Returns
///
/// a new [`MapListModel`][crate::MapListModel]
#[doc(alias = "gtk_map_list_model_new")]
pub fn new<P: Fn(&glib::Object) -> glib::Object + 'static>(
model: Option<impl IsA<gio::ListModel>>,
map_func: P,
) -> MapListModel {
assert_initialized_main_thread!();
let map_func_data: Box_<P> = Box_::new(map_func);
unsafe extern "C" fn map_func_func<P: Fn(&glib::Object) -> glib::Object + 'static>(
item: *mut glib::gobject_ffi::GObject,
user_data: glib::ffi::gpointer,
) -> *mut glib::gobject_ffi::GObject {
let item = from_glib_full(item);
let callback = &*(user_data as *mut P);
(*callback)(&item).to_glib_full()
}
let map_func = Some(map_func_func::<P> as _);
unsafe extern "C" fn user_destroy_func<P: Fn(&glib::Object) -> glib::Object + 'static>(
data: glib::ffi::gpointer,
) {
let _callback = Box_::from_raw(data as *mut P);
}
let destroy_call3 = Some(user_destroy_func::<P> as _);
let super_callback0: Box_<P> = map_func_data;
unsafe {
from_glib_full(ffi::gtk_map_list_model_new(
model.map(|p| p.upcast()).into_glib_ptr(),
map_func,
Box_::into_raw(super_callback0) as *mut _,
destroy_call3,
))
}
}
/// Gets the model that is currently being mapped or [`None`] if none.
///
/// # Returns
///
/// The model that gets mapped
#[doc(alias = "gtk_map_list_model_get_model")]
#[doc(alias = "get_model")]
pub fn model(&self) -> Option<gio::ListModel> {
unsafe { from_glib_none(ffi::gtk_map_list_model_get_model(self.to_glib_none().0)) }
}
/// Checks if a map function is currently set on @self.
///
/// # Returns
///
/// [`true`] if a map function is set
#[doc(alias = "gtk_map_list_model_has_map")]
#[doc(alias = "has-map")]
pub fn has_map(&self) -> bool {
unsafe { from_glib(ffi::gtk_map_list_model_has_map(self.to_glib_none().0)) }
}
/// Sets the function used to map items.
///
/// The function will be called whenever an item needs to be mapped
/// and must return the item to use for the given input item.
///
/// Note that [`MapListModel`][crate::MapListModel] may call this function multiple times
/// on the same item, because it may delete items it doesn't need anymore.
///
/// GTK makes no effort to ensure that @map_func conforms to the item type
/// of @self. It assumes that the caller knows what they are doing and the map
/// function returns items of the appropriate type.
/// ## `map_func`
/// map function
#[doc(alias = "gtk_map_list_model_set_map_func")]
pub fn set_map_func<P: Fn(&glib::Object) -> glib::Object + 'static>(&self, map_func: P) {
let map_func_data: Box_<P> = Box_::new(map_func);
unsafe extern "C" fn map_func_func<P: Fn(&glib::Object) -> glib::Object + 'static>(
item: *mut glib::gobject_ffi::GObject,
user_data: glib::ffi::gpointer,
) -> *mut glib::gobject_ffi::GObject {
let item = from_glib_full(item);
let callback = &*(user_data as *mut P);
(*callback)(&item).to_glib_full()
}
let map_func = Some(map_func_func::<P> as _);
unsafe extern "C" fn user_destroy_func<P: Fn(&glib::Object) -> glib::Object + 'static>(
data: glib::ffi::gpointer,
) {
let _callback = Box_::from_raw(data as *mut P);
}
let destroy_call3 = Some(user_destroy_func::<P> as _);
let super_callback0: Box_<P> = map_func_data;
unsafe {
ffi::gtk_map_list_model_set_map_func(
self.to_glib_none().0,
map_func,
Box_::into_raw(super_callback0) as *mut _,
destroy_call3,
);
}
}
/// Sets the model to be mapped.
///
/// GTK makes no effort to ensure that @model conforms to the item type
/// expected by the map function. It assumes that the caller knows what
/// they are doing and have set up an appropriate map function.
/// ## `model`
/// The model to be mapped
#[doc(alias = "gtk_map_list_model_set_model")]
pub fn set_model(&self, model: Option<&impl IsA<gio::ListModel>>) {
unsafe {
ffi::gtk_map_list_model_set_model(
self.to_glib_none().0,
model.map(|p| p.as_ref()).to_glib_none().0,
);
}
}
#[doc(alias = "has-map")]
pub fn connect_has_map_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_has_map_trampoline<F: Fn(&MapListModel) + 'static>(
this: *mut ffi::GtkMapListModel,
_param_spec: glib::ffi::gpointer,
f: glib::ffi::gpointer,
) {
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 _,
b"notify::has-map\0".as_ptr() as *const _,
Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
notify_has_map_trampoline::<F> as *const (),
)),
Box_::into_raw(f),
)
}
}
}