gtk/auto/
cell_renderer_toggle.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use crate::{CellRenderer, CellRendererMode, TreePath};
6use glib::{
7    prelude::*,
8    signal::{connect_raw, SignalHandlerId},
9    translate::*,
10};
11use std::{boxed::Box as Box_, fmt, mem::transmute};
12
13glib::wrapper! {
14    #[doc(alias = "GtkCellRendererToggle")]
15    pub struct CellRendererToggle(Object<ffi::GtkCellRendererToggle, ffi::GtkCellRendererToggleClass>) @extends CellRenderer;
16
17    match fn {
18        type_ => || ffi::gtk_cell_renderer_toggle_get_type(),
19    }
20}
21
22impl CellRendererToggle {
23    pub const NONE: Option<&'static CellRendererToggle> = None;
24
25    #[doc(alias = "gtk_cell_renderer_toggle_new")]
26    pub fn new() -> CellRendererToggle {
27        assert_initialized_main_thread!();
28        unsafe { CellRenderer::from_glib_none(ffi::gtk_cell_renderer_toggle_new()).unsafe_cast() }
29    }
30
31    // rustdoc-stripper-ignore-next
32    /// Creates a new builder-pattern struct instance to construct [`CellRendererToggle`] objects.
33    ///
34    /// This method returns an instance of [`CellRendererToggleBuilder`](crate::builders::CellRendererToggleBuilder) which can be used to create [`CellRendererToggle`] objects.
35    pub fn builder() -> CellRendererToggleBuilder {
36        CellRendererToggleBuilder::new()
37    }
38}
39
40impl Default for CellRendererToggle {
41    fn default() -> Self {
42        Self::new()
43    }
44}
45
46// rustdoc-stripper-ignore-next
47/// A [builder-pattern] type to construct [`CellRendererToggle`] objects.
48///
49/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
50#[must_use = "The builder must be built to be used"]
51pub struct CellRendererToggleBuilder {
52    builder: glib::object::ObjectBuilder<'static, CellRendererToggle>,
53}
54
55impl CellRendererToggleBuilder {
56    fn new() -> Self {
57        Self {
58            builder: glib::object::Object::builder(),
59        }
60    }
61
62    pub fn activatable(self, activatable: bool) -> Self {
63        Self {
64            builder: self.builder.property("activatable", activatable),
65        }
66    }
67
68    pub fn active(self, active: bool) -> Self {
69        Self {
70            builder: self.builder.property("active", active),
71        }
72    }
73
74    pub fn inconsistent(self, inconsistent: bool) -> Self {
75        Self {
76            builder: self.builder.property("inconsistent", inconsistent),
77        }
78    }
79
80    pub fn indicator_size(self, indicator_size: i32) -> Self {
81        Self {
82            builder: self.builder.property("indicator-size", indicator_size),
83        }
84    }
85
86    pub fn radio(self, radio: bool) -> Self {
87        Self {
88            builder: self.builder.property("radio", radio),
89        }
90    }
91
92    pub fn cell_background(self, cell_background: impl Into<glib::GString>) -> Self {
93        Self {
94            builder: self
95                .builder
96                .property("cell-background", cell_background.into()),
97        }
98    }
99
100    pub fn cell_background_rgba(self, cell_background_rgba: &gdk::RGBA) -> Self {
101        Self {
102            builder: self
103                .builder
104                .property("cell-background-rgba", cell_background_rgba),
105        }
106    }
107
108    pub fn cell_background_set(self, cell_background_set: bool) -> Self {
109        Self {
110            builder: self
111                .builder
112                .property("cell-background-set", cell_background_set),
113        }
114    }
115
116    pub fn height(self, height: i32) -> Self {
117        Self {
118            builder: self.builder.property("height", height),
119        }
120    }
121
122    pub fn is_expanded(self, is_expanded: bool) -> Self {
123        Self {
124            builder: self.builder.property("is-expanded", is_expanded),
125        }
126    }
127
128    pub fn is_expander(self, is_expander: bool) -> Self {
129        Self {
130            builder: self.builder.property("is-expander", is_expander),
131        }
132    }
133
134    pub fn mode(self, mode: CellRendererMode) -> Self {
135        Self {
136            builder: self.builder.property("mode", mode),
137        }
138    }
139
140    pub fn sensitive(self, sensitive: bool) -> Self {
141        Self {
142            builder: self.builder.property("sensitive", sensitive),
143        }
144    }
145
146    pub fn visible(self, visible: bool) -> Self {
147        Self {
148            builder: self.builder.property("visible", visible),
149        }
150    }
151
152    pub fn width(self, width: i32) -> Self {
153        Self {
154            builder: self.builder.property("width", width),
155        }
156    }
157
158    pub fn xalign(self, xalign: f32) -> Self {
159        Self {
160            builder: self.builder.property("xalign", xalign),
161        }
162    }
163
164    pub fn xpad(self, xpad: u32) -> Self {
165        Self {
166            builder: self.builder.property("xpad", xpad),
167        }
168    }
169
170    pub fn yalign(self, yalign: f32) -> Self {
171        Self {
172            builder: self.builder.property("yalign", yalign),
173        }
174    }
175
176    pub fn ypad(self, ypad: u32) -> Self {
177        Self {
178            builder: self.builder.property("ypad", ypad),
179        }
180    }
181
182    // rustdoc-stripper-ignore-next
183    /// Build the [`CellRendererToggle`].
184    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
185    pub fn build(self) -> CellRendererToggle {
186        self.builder.build()
187    }
188}
189
190mod sealed {
191    pub trait Sealed {}
192    impl<T: super::IsA<super::CellRendererToggle>> Sealed for T {}
193}
194
195pub trait CellRendererToggleExt: IsA<CellRendererToggle> + sealed::Sealed + 'static {
196    #[doc(alias = "gtk_cell_renderer_toggle_get_activatable")]
197    #[doc(alias = "get_activatable")]
198    fn is_activatable(&self) -> bool {
199        unsafe {
200            from_glib(ffi::gtk_cell_renderer_toggle_get_activatable(
201                self.as_ref().to_glib_none().0,
202            ))
203        }
204    }
205
206    #[doc(alias = "gtk_cell_renderer_toggle_get_active")]
207    #[doc(alias = "get_active")]
208    fn is_active(&self) -> bool {
209        unsafe {
210            from_glib(ffi::gtk_cell_renderer_toggle_get_active(
211                self.as_ref().to_glib_none().0,
212            ))
213        }
214    }
215
216    #[doc(alias = "gtk_cell_renderer_toggle_get_radio")]
217    #[doc(alias = "get_radio")]
218    fn is_radio(&self) -> bool {
219        unsafe {
220            from_glib(ffi::gtk_cell_renderer_toggle_get_radio(
221                self.as_ref().to_glib_none().0,
222            ))
223        }
224    }
225
226    #[doc(alias = "gtk_cell_renderer_toggle_set_activatable")]
227    fn set_activatable(&self, setting: bool) {
228        unsafe {
229            ffi::gtk_cell_renderer_toggle_set_activatable(
230                self.as_ref().to_glib_none().0,
231                setting.into_glib(),
232            );
233        }
234    }
235
236    #[doc(alias = "gtk_cell_renderer_toggle_set_active")]
237    fn set_active(&self, setting: bool) {
238        unsafe {
239            ffi::gtk_cell_renderer_toggle_set_active(
240                self.as_ref().to_glib_none().0,
241                setting.into_glib(),
242            );
243        }
244    }
245
246    #[doc(alias = "gtk_cell_renderer_toggle_set_radio")]
247    fn set_radio(&self, radio: bool) {
248        unsafe {
249            ffi::gtk_cell_renderer_toggle_set_radio(
250                self.as_ref().to_glib_none().0,
251                radio.into_glib(),
252            );
253        }
254    }
255
256    fn is_inconsistent(&self) -> bool {
257        ObjectExt::property(self.as_ref(), "inconsistent")
258    }
259
260    fn set_inconsistent(&self, inconsistent: bool) {
261        ObjectExt::set_property(self.as_ref(), "inconsistent", inconsistent)
262    }
263
264    #[doc(alias = "indicator-size")]
265    fn indicator_size(&self) -> i32 {
266        ObjectExt::property(self.as_ref(), "indicator-size")
267    }
268
269    #[doc(alias = "indicator-size")]
270    fn set_indicator_size(&self, indicator_size: i32) {
271        ObjectExt::set_property(self.as_ref(), "indicator-size", indicator_size)
272    }
273
274    #[doc(alias = "toggled")]
275    fn connect_toggled<F: Fn(&Self, TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
276        unsafe extern "C" fn toggled_trampoline<
277            P: IsA<CellRendererToggle>,
278            F: Fn(&P, TreePath) + 'static,
279        >(
280            this: *mut ffi::GtkCellRendererToggle,
281            path: *mut libc::c_char,
282            f: glib::ffi::gpointer,
283        ) {
284            let f: &F = &*(f as *const F);
285            let path = from_glib_full(crate::ffi::gtk_tree_path_new_from_string(path));
286            f(
287                CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref(),
288                path,
289            )
290        }
291        unsafe {
292            let f: Box_<F> = Box_::new(f);
293            connect_raw(
294                self.as_ptr() as *mut _,
295                b"toggled\0".as_ptr() as *const _,
296                Some(transmute::<_, unsafe extern "C" fn()>(
297                    toggled_trampoline::<Self, F> as *const (),
298                )),
299                Box_::into_raw(f),
300            )
301        }
302    }
303
304    #[doc(alias = "activatable")]
305    fn connect_activatable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
306        unsafe extern "C" fn notify_activatable_trampoline<
307            P: IsA<CellRendererToggle>,
308            F: Fn(&P) + 'static,
309        >(
310            this: *mut ffi::GtkCellRendererToggle,
311            _param_spec: glib::ffi::gpointer,
312            f: glib::ffi::gpointer,
313        ) {
314            let f: &F = &*(f as *const F);
315            f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
316        }
317        unsafe {
318            let f: Box_<F> = Box_::new(f);
319            connect_raw(
320                self.as_ptr() as *mut _,
321                b"notify::activatable\0".as_ptr() as *const _,
322                Some(transmute::<_, unsafe extern "C" fn()>(
323                    notify_activatable_trampoline::<Self, F> as *const (),
324                )),
325                Box_::into_raw(f),
326            )
327        }
328    }
329
330    #[doc(alias = "active")]
331    fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
332        unsafe extern "C" fn notify_active_trampoline<
333            P: IsA<CellRendererToggle>,
334            F: Fn(&P) + 'static,
335        >(
336            this: *mut ffi::GtkCellRendererToggle,
337            _param_spec: glib::ffi::gpointer,
338            f: glib::ffi::gpointer,
339        ) {
340            let f: &F = &*(f as *const F);
341            f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
342        }
343        unsafe {
344            let f: Box_<F> = Box_::new(f);
345            connect_raw(
346                self.as_ptr() as *mut _,
347                b"notify::active\0".as_ptr() as *const _,
348                Some(transmute::<_, unsafe extern "C" fn()>(
349                    notify_active_trampoline::<Self, F> as *const (),
350                )),
351                Box_::into_raw(f),
352            )
353        }
354    }
355
356    #[doc(alias = "inconsistent")]
357    fn connect_inconsistent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
358        unsafe extern "C" fn notify_inconsistent_trampoline<
359            P: IsA<CellRendererToggle>,
360            F: Fn(&P) + 'static,
361        >(
362            this: *mut ffi::GtkCellRendererToggle,
363            _param_spec: glib::ffi::gpointer,
364            f: glib::ffi::gpointer,
365        ) {
366            let f: &F = &*(f as *const F);
367            f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
368        }
369        unsafe {
370            let f: Box_<F> = Box_::new(f);
371            connect_raw(
372                self.as_ptr() as *mut _,
373                b"notify::inconsistent\0".as_ptr() as *const _,
374                Some(transmute::<_, unsafe extern "C" fn()>(
375                    notify_inconsistent_trampoline::<Self, F> as *const (),
376                )),
377                Box_::into_raw(f),
378            )
379        }
380    }
381
382    #[doc(alias = "indicator-size")]
383    fn connect_indicator_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
384        unsafe extern "C" fn notify_indicator_size_trampoline<
385            P: IsA<CellRendererToggle>,
386            F: Fn(&P) + 'static,
387        >(
388            this: *mut ffi::GtkCellRendererToggle,
389            _param_spec: glib::ffi::gpointer,
390            f: glib::ffi::gpointer,
391        ) {
392            let f: &F = &*(f as *const F);
393            f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
394        }
395        unsafe {
396            let f: Box_<F> = Box_::new(f);
397            connect_raw(
398                self.as_ptr() as *mut _,
399                b"notify::indicator-size\0".as_ptr() as *const _,
400                Some(transmute::<_, unsafe extern "C" fn()>(
401                    notify_indicator_size_trampoline::<Self, F> as *const (),
402                )),
403                Box_::into_raw(f),
404            )
405        }
406    }
407
408    #[doc(alias = "radio")]
409    fn connect_radio_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
410        unsafe extern "C" fn notify_radio_trampoline<
411            P: IsA<CellRendererToggle>,
412            F: Fn(&P) + 'static,
413        >(
414            this: *mut ffi::GtkCellRendererToggle,
415            _param_spec: glib::ffi::gpointer,
416            f: glib::ffi::gpointer,
417        ) {
418            let f: &F = &*(f as *const F);
419            f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
420        }
421        unsafe {
422            let f: Box_<F> = Box_::new(f);
423            connect_raw(
424                self.as_ptr() as *mut _,
425                b"notify::radio\0".as_ptr() as *const _,
426                Some(transmute::<_, unsafe extern "C" fn()>(
427                    notify_radio_trampoline::<Self, F> as *const (),
428                )),
429                Box_::into_raw(f),
430            )
431        }
432    }
433}
434
435impl<O: IsA<CellRendererToggle>> CellRendererToggleExt for O {}
436
437impl fmt::Display for CellRendererToggle {
438    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
439        f.write_str("CellRendererToggle")
440    }
441}
gtk/auto/cell_renderer_toggle.rs

gtk/auto/
cell_renderer_toggle.rs
