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
245
246
247
248
249
// 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::ListItemFactory;
use glib::object::Cast;
#[cfg(any(feature = "v4_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
use glib::object::ObjectType as ObjectType_;
#[cfg(any(feature = "v4_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
use glib::signal::connect_raw;
#[cfg(any(feature = "v4_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
use glib::signal::SignalHandlerId;
use glib::translate::*;
#[cfg(any(feature = "v4_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
use std::boxed::Box as Box_;
use std::fmt;
#[cfg(any(feature = "v4_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
use std::mem::transmute;

glib::wrapper! {
    /// [`SignalListItemFactory`][crate::SignalListItemFactory] is a [`ListItemFactory`][crate::ListItemFactory] that emits signals
    /// to to manage listitems.
    ///
    /// Signals are emitted for every listitem in the same order:
    ///
    ///  1. `signal::SignalListItemFactory::setup` is emitted to set up permanent
    ///  things on the listitem. This usually means constructing the widgets used in
    ///  the row and adding them to the listitem.
    ///
    ///  2. `signal::SignalListItemFactory::bind` is emitted to bind the item passed
    ///  via `property::ListItem::item` to the widgets that have been created in
    ///  step 1 or to add item-specific widgets. Signals are connected to listen to
    ///  changes - both to changes in the item to update the widgets or to changes
    ///  in the widgets to update the item. After this signal has been called, the
    ///  listitem may be shown in a list widget.
    ///
    ///  3. `signal::SignalListItemFactory::unbind` is emitted to undo everything
    ///  done in step 2. Usually this means disconnecting signal handlers. Once this
    ///  signal has been called, the listitem will no longer be used in a list
    ///  widget.
    ///
    ///  4. `signal::SignalListItemFactory::bind` and
    ///  `signal::SignalListItemFactory::unbind` may be emitted multiple times
    ///  again to bind the listitem for use with new items. By reusing listitems,
    ///  potentially costly setup can be avoided. However, it means code needs to
    ///  make sure to properly clean up the listitem in step 3 so that no information
    ///  from the previous use leaks into the next use.
    ///
    /// 5. `signal::SignalListItemFactory::teardown` is emitted to allow undoing
    /// the effects of `signal::SignalListItemFactory::setup`. After this signal
    /// was emitted on a listitem, the listitem will be destroyed and not be used again.
    ///
    /// Note that during the signal emissions, changing properties on the
    /// [`ListItem`][crate::ListItem]s passed will not trigger notify signals as the listitem's
    /// notifications are frozen. See g_object_freeze_notify() for details.
    ///
    /// For tracking changes in other properties in the [`ListItem`][crate::ListItem], the
    /// ::notify signal is recommended. The signal can be connected in the
    /// `signal::SignalListItemFactory::setup` signal and removed again during
    /// `signal::SignalListItemFactory::teardown`.
    ///
    /// # Implements
    ///
    /// [`ListItemFactoryExt`][trait@crate::prelude::ListItemFactoryExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkSignalListItemFactory")]
    pub struct SignalListItemFactory(Object<ffi::GtkSignalListItemFactory, ffi::GtkSignalListItemFactoryClass>) @extends ListItemFactory;

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

impl SignalListItemFactory {
    /// Creates a new [`SignalListItemFactory`][crate::SignalListItemFactory].
    ///
    /// You need to connect signal handlers before you use it.
    ///
    /// # Returns
    ///
    /// a new [`SignalListItemFactory`][crate::SignalListItemFactory]
    #[doc(alias = "gtk_signal_list_item_factory_new")]
    pub fn new() -> SignalListItemFactory {
        assert_initialized_main_thread!();
        unsafe {
            ListItemFactory::from_glib_full(ffi::gtk_signal_list_item_factory_new()).unsafe_cast()
        }
    }

    /// Emitted when an object has been bound, for example when a
    /// new `property::ListItem::item` has been set on a
    /// [`ListItem`][crate::ListItem] and should be bound for use.
    ///
    /// After this signal was emitted, the object might be shown in
    /// a [`ListView`][crate::ListView] or other widget.
    ///
    /// The `signal::SignalListItemFactory::unbind` signal is the
    /// opposite of this signal and can be used to undo everything done
    /// in this signal.
    /// ## `object`
    /// The `GObject` to bind
    #[cfg(any(feature = "v4_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
    #[doc(alias = "bind")]
    pub fn connect_bind<F: Fn(&Self, &glib::Object) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn bind_trampoline<
            F: Fn(&SignalListItemFactory, &glib::Object) + 'static,
        >(
            this: *mut ffi::GtkSignalListItemFactory,
            object: *mut glib::gobject_ffi::GObject,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(object))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"bind\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    bind_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a new listitem has been created and needs to be setup for use.
    ///
    /// It is the first signal emitted for every listitem.
    ///
    /// The `signal::SignalListItemFactory::teardown` signal is the opposite
    /// of this signal and can be used to undo everything done in this signal.
    /// ## `object`
    /// The `GObject` to set up
    #[cfg(any(feature = "v4_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
    #[doc(alias = "setup")]
    pub fn connect_setup<F: Fn(&Self, &glib::Object) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn setup_trampoline<
            F: Fn(&SignalListItemFactory, &glib::Object) + 'static,
        >(
            this: *mut ffi::GtkSignalListItemFactory,
            object: *mut glib::gobject_ffi::GObject,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(object))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"setup\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    setup_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when an object is about to be destroyed.
    ///
    /// It is the last signal ever emitted for this @object.
    ///
    /// This signal is the opposite of the `signal::SignalListItemFactory::setup`
    /// signal and should be used to undo everything done in that signal.
    /// ## `object`
    /// The `GObject` to tear down
    #[cfg(any(feature = "v4_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
    #[doc(alias = "teardown")]
    pub fn connect_teardown<F: Fn(&Self, &glib::Object) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn teardown_trampoline<
            F: Fn(&SignalListItemFactory, &glib::Object) + 'static,
        >(
            this: *mut ffi::GtkSignalListItemFactory,
            object: *mut glib::gobject_ffi::GObject,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(object))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"teardown\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    teardown_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a object has been unbound from its item, for example when
    /// a listitem was removed from use in a list widget
    /// and its new `property::ListItem::item` is about to be unset.
    ///
    /// This signal is the opposite of the `signal::SignalListItemFactory::bind`
    /// signal and should be used to undo everything done in that signal.
    /// ## `object`
    /// The `GObject` to unbind
    #[cfg(any(feature = "v4_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
    #[doc(alias = "unbind")]
    pub fn connect_unbind<F: Fn(&Self, &glib::Object) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn unbind_trampoline<
            F: Fn(&SignalListItemFactory, &glib::Object) + 'static,
        >(
            this: *mut ffi::GtkSignalListItemFactory,
            object: *mut glib::gobject_ffi::GObject,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(object))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"unbind\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    unbind_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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

impl fmt::Display for SignalListItemFactory {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("SignalListItemFactory")
    }
}