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, ffi};
6use glib::{
7    object::ObjectType as _,
8    prelude::*,
9    signal::{SignalHandlerId, connect_raw},
10    translate::*,
11};
12use std::boxed::Box as Box_;
13
14glib::wrapper! {
15    /// [`CellRendererToggle`][crate::CellRendererToggle] renders a toggle button in a cell. The
16    /// button is drawn as a radio or a checkbutton, depending on the
17    /// [`radio`][struct@crate::CellRendererToggle#radio] property.
18    /// When activated, it emits the [`toggled`][struct@crate::CellRendererToggle#toggled] signal.
19    ///
20    /// ## Properties
21    ///
22    ///
23    /// #### `activatable`
24    ///  Readable | Writable
25    ///
26    ///
27    /// #### `active`
28    ///  Readable | Writable
29    ///
30    ///
31    /// #### `inconsistent`
32    ///  Readable | Writable
33    ///
34    ///
35    /// #### `indicator-size`
36    ///  Readable | Writable
37    ///
38    ///
39    /// #### `radio`
40    ///  Readable | Writable
41    /// <details><summary><h4>CellRenderer</h4></summary>
42    ///
43    ///
44    /// #### `cell-background`
45    ///  Writable
46    ///
47    ///
48    /// #### `cell-background-gdk`
49    ///  Cell background as a `GdkColor`
50    ///
51    /// Readable | Writable
52    ///
53    ///
54    /// #### `cell-background-rgba`
55    ///  Cell background as a [`gdk::RGBA`][crate::gdk::RGBA]
56    ///
57    /// Readable | Writable
58    ///
59    ///
60    /// #### `cell-background-set`
61    ///  Readable | Writable
62    ///
63    ///
64    /// #### `editing`
65    ///  Readable
66    ///
67    ///
68    /// #### `height`
69    ///  Readable | Writable
70    ///
71    ///
72    /// #### `is-expanded`
73    ///  Readable | Writable
74    ///
75    ///
76    /// #### `is-expander`
77    ///  Readable | Writable
78    ///
79    ///
80    /// #### `mode`
81    ///  Readable | Writable
82    ///
83    ///
84    /// #### `sensitive`
85    ///  Readable | Writable
86    ///
87    ///
88    /// #### `visible`
89    ///  Readable | Writable
90    ///
91    ///
92    /// #### `width`
93    ///  Readable | Writable
94    ///
95    ///
96    /// #### `xalign`
97    ///  Readable | Writable
98    ///
99    ///
100    /// #### `xpad`
101    ///  Readable | Writable
102    ///
103    ///
104    /// #### `yalign`
105    ///  Readable | Writable
106    ///
107    ///
108    /// #### `ypad`
109    ///  Readable | Writable
110    /// </details>
111    ///
112    /// ## Signals
113    ///
114    ///
115    /// #### `toggled`
116    ///  The ::toggled signal is emitted when the cell is toggled.
117    ///
118    /// It is the responsibility of the application to update the model
119    /// with the correct value to store at `path`. Often this is simply the
120    /// opposite of the value currently stored at `path`.
121    ///
122    ///
123    /// <details><summary><h4>CellRenderer</h4></summary>
124    ///
125    ///
126    /// #### `editing-canceled`
127    ///  This signal gets emitted when the user cancels the process of editing a
128    /// cell. For example, an editable cell renderer could be written to cancel
129    /// editing when the user presses Escape.
130    ///
131    /// See also: [`CellRendererExt::stop_editing()`][crate::prelude::CellRendererExt::stop_editing()].
132    ///
133    ///
134    ///
135    ///
136    /// #### `editing-started`
137    ///  This signal gets emitted when a cell starts to be edited.
138    /// The intended use of this signal is to do special setup
139    /// on `editable`, e.g. adding a [`EntryCompletion`][crate::EntryCompletion] or setting
140    /// up additional columns in a [`ComboBox`][crate::ComboBox].
141    ///
142    /// See [`CellEditableExt::start_editing()`][crate::prelude::CellEditableExt::start_editing()] for information on the lifecycle of
143    /// the `editable` and a way to do setup that doesn’t depend on the `renderer`.
144    ///
145    /// Note that GTK+ doesn't guarantee that cell renderers will
146    /// continue to use the same kind of widget for editing in future
147    /// releases, therefore you should check the type of `editable`
148    /// before doing any specific setup, as in the following example:
149    ///
150    ///
151    /// **⚠️ The following code is in C ⚠️**
152    ///
153    /// ```C
154    /// static void
155    /// text_editing_started (GtkCellRenderer *cell,
156    ///                       GtkCellEditable *editable,
157    ///                       const gchar     *path,
158    ///                       gpointer         data)
159    /// {
160    ///   if (GTK_IS_ENTRY (editable))
161    ///     {
162    ///       GtkEntry *entry = GTK_ENTRY (editable);
163    ///
164    ///       // ... create a GtkEntryCompletion
165    ///
166    ///       gtk_entry_set_completion (entry, completion);
167    ///     }
168    /// }
169    /// ```
170    ///
171    ///
172    /// </details>
173    ///
174    /// # Implements
175    ///
176    /// [`CellRendererToggleExt`][trait@crate::prelude::CellRendererToggleExt], [`CellRendererExt`][trait@crate::prelude::CellRendererExt], [`trait@glib::ObjectExt`]
177    #[doc(alias = "GtkCellRendererToggle")]
178    pub struct CellRendererToggle(Object<ffi::GtkCellRendererToggle, ffi::GtkCellRendererToggleClass>) @extends CellRenderer;
179
180    match fn {
181        type_ => || ffi::gtk_cell_renderer_toggle_get_type(),
182    }
183}
184
185impl CellRendererToggle {
186    pub const NONE: Option<&'static CellRendererToggle> = None;
187
188    /// Creates a new [`CellRendererToggle`][crate::CellRendererToggle]. Adjust rendering
189    /// parameters using object properties. Object properties can be set
190    /// globally (with [`ObjectExt::set()`][crate::glib::prelude::ObjectExt::set()]). Also, with [`TreeViewColumn`][crate::TreeViewColumn], you
191    /// can bind a property to a value in a [`TreeModel`][crate::TreeModel]. For example, you
192    /// can bind the “active” property on the cell renderer to a boolean value
193    /// in the model, thus causing the check button to reflect the state of
194    /// the model.
195    ///
196    /// # Returns
197    ///
198    /// the new cell renderer
199    #[doc(alias = "gtk_cell_renderer_toggle_new")]
200    pub fn new() -> CellRendererToggle {
201        assert_initialized_main_thread!();
202        unsafe { CellRenderer::from_glib_none(ffi::gtk_cell_renderer_toggle_new()).unsafe_cast() }
203    }
204
205    // rustdoc-stripper-ignore-next
206    /// Creates a new builder-pattern struct instance to construct [`CellRendererToggle`] objects.
207    ///
208    /// This method returns an instance of [`CellRendererToggleBuilder`](crate::builders::CellRendererToggleBuilder) which can be used to create [`CellRendererToggle`] objects.
209    pub fn builder() -> CellRendererToggleBuilder {
210        CellRendererToggleBuilder::new()
211    }
212}
213
214impl Default for CellRendererToggle {
215    fn default() -> Self {
216        Self::new()
217    }
218}
219
220// rustdoc-stripper-ignore-next
221/// A [builder-pattern] type to construct [`CellRendererToggle`] objects.
222///
223/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
224#[must_use = "The builder must be built to be used"]
225pub struct CellRendererToggleBuilder {
226    builder: glib::object::ObjectBuilder<'static, CellRendererToggle>,
227}
228
229impl CellRendererToggleBuilder {
230    fn new() -> Self {
231        Self {
232            builder: glib::object::Object::builder(),
233        }
234    }
235
236    pub fn activatable(self, activatable: bool) -> Self {
237        Self {
238            builder: self.builder.property("activatable", activatable),
239        }
240    }
241
242    pub fn active(self, active: bool) -> Self {
243        Self {
244            builder: self.builder.property("active", active),
245        }
246    }
247
248    pub fn inconsistent(self, inconsistent: bool) -> Self {
249        Self {
250            builder: self.builder.property("inconsistent", inconsistent),
251        }
252    }
253
254    pub fn indicator_size(self, indicator_size: i32) -> Self {
255        Self {
256            builder: self.builder.property("indicator-size", indicator_size),
257        }
258    }
259
260    pub fn radio(self, radio: bool) -> Self {
261        Self {
262            builder: self.builder.property("radio", radio),
263        }
264    }
265
266    pub fn cell_background(self, cell_background: impl Into<glib::GString>) -> Self {
267        Self {
268            builder: self
269                .builder
270                .property("cell-background", cell_background.into()),
271        }
272    }
273
274    /// Cell background as a [`gdk::RGBA`][crate::gdk::RGBA]
275    pub fn cell_background_rgba(self, cell_background_rgba: &gdk::RGBA) -> Self {
276        Self {
277            builder: self
278                .builder
279                .property("cell-background-rgba", cell_background_rgba),
280        }
281    }
282
283    pub fn cell_background_set(self, cell_background_set: bool) -> Self {
284        Self {
285            builder: self
286                .builder
287                .property("cell-background-set", cell_background_set),
288        }
289    }
290
291    pub fn height(self, height: i32) -> Self {
292        Self {
293            builder: self.builder.property("height", height),
294        }
295    }
296
297    pub fn is_expanded(self, is_expanded: bool) -> Self {
298        Self {
299            builder: self.builder.property("is-expanded", is_expanded),
300        }
301    }
302
303    pub fn is_expander(self, is_expander: bool) -> Self {
304        Self {
305            builder: self.builder.property("is-expander", is_expander),
306        }
307    }
308
309    pub fn mode(self, mode: CellRendererMode) -> Self {
310        Self {
311            builder: self.builder.property("mode", mode),
312        }
313    }
314
315    pub fn sensitive(self, sensitive: bool) -> Self {
316        Self {
317            builder: self.builder.property("sensitive", sensitive),
318        }
319    }
320
321    pub fn visible(self, visible: bool) -> Self {
322        Self {
323            builder: self.builder.property("visible", visible),
324        }
325    }
326
327    pub fn width(self, width: i32) -> Self {
328        Self {
329            builder: self.builder.property("width", width),
330        }
331    }
332
333    pub fn xalign(self, xalign: f32) -> Self {
334        Self {
335            builder: self.builder.property("xalign", xalign),
336        }
337    }
338
339    pub fn xpad(self, xpad: u32) -> Self {
340        Self {
341            builder: self.builder.property("xpad", xpad),
342        }
343    }
344
345    pub fn yalign(self, yalign: f32) -> Self {
346        Self {
347            builder: self.builder.property("yalign", yalign),
348        }
349    }
350
351    pub fn ypad(self, ypad: u32) -> Self {
352        Self {
353            builder: self.builder.property("ypad", ypad),
354        }
355    }
356
357    // rustdoc-stripper-ignore-next
358    /// Build the [`CellRendererToggle`].
359    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
360    pub fn build(self) -> CellRendererToggle {
361        assert_initialized_main_thread!();
362        self.builder.build()
363    }
364}
365
366/// Trait containing all [`struct@CellRendererToggle`] methods.
367///
368/// # Implementors
369///
370/// [`CellRendererToggle`][struct@crate::CellRendererToggle]
371pub trait CellRendererToggleExt: IsA<CellRendererToggle> + 'static {
372    /// Returns whether the cell renderer is activatable. See
373    /// [`set_activatable()`][Self::set_activatable()].
374    ///
375    /// # Returns
376    ///
377    /// [`true`] if the cell renderer is activatable.
378    #[doc(alias = "gtk_cell_renderer_toggle_get_activatable")]
379    #[doc(alias = "get_activatable")]
380    #[doc(alias = "activatable")]
381    fn is_activatable(&self) -> bool {
382        unsafe {
383            from_glib(ffi::gtk_cell_renderer_toggle_get_activatable(
384                self.as_ref().to_glib_none().0,
385            ))
386        }
387    }
388
389    /// Returns whether the cell renderer is active. See
390    /// [`set_active()`][Self::set_active()].
391    ///
392    /// # Returns
393    ///
394    /// [`true`] if the cell renderer is active.
395    #[doc(alias = "gtk_cell_renderer_toggle_get_active")]
396    #[doc(alias = "get_active")]
397    #[doc(alias = "active")]
398    fn is_active(&self) -> bool {
399        unsafe {
400            from_glib(ffi::gtk_cell_renderer_toggle_get_active(
401                self.as_ref().to_glib_none().0,
402            ))
403        }
404    }
405
406    /// Returns whether we’re rendering radio toggles rather than checkboxes.
407    ///
408    /// # Returns
409    ///
410    /// [`true`] if we’re rendering radio toggles rather than checkboxes
411    #[doc(alias = "gtk_cell_renderer_toggle_get_radio")]
412    #[doc(alias = "get_radio")]
413    #[doc(alias = "radio")]
414    fn is_radio(&self) -> bool {
415        unsafe {
416            from_glib(ffi::gtk_cell_renderer_toggle_get_radio(
417                self.as_ref().to_glib_none().0,
418            ))
419        }
420    }
421
422    /// Makes the cell renderer activatable.
423    /// ## `setting`
424    /// the value to set.
425    #[doc(alias = "gtk_cell_renderer_toggle_set_activatable")]
426    #[doc(alias = "activatable")]
427    fn set_activatable(&self, setting: bool) {
428        unsafe {
429            ffi::gtk_cell_renderer_toggle_set_activatable(
430                self.as_ref().to_glib_none().0,
431                setting.into_glib(),
432            );
433        }
434    }
435
436    /// Activates or deactivates a cell renderer.
437    /// ## `setting`
438    /// the value to set.
439    #[doc(alias = "gtk_cell_renderer_toggle_set_active")]
440    #[doc(alias = "active")]
441    fn set_active(&self, setting: bool) {
442        unsafe {
443            ffi::gtk_cell_renderer_toggle_set_active(
444                self.as_ref().to_glib_none().0,
445                setting.into_glib(),
446            );
447        }
448    }
449
450    /// If `radio` is [`true`], the cell renderer renders a radio toggle
451    /// (i.e. a toggle in a group of mutually-exclusive toggles).
452    /// If [`false`], it renders a check toggle (a standalone boolean option).
453    /// This can be set globally for the cell renderer, or changed just
454    /// before rendering each cell in the model (for [`TreeView`][crate::TreeView], you set
455    /// up a per-row setting using [`TreeViewColumn`][crate::TreeViewColumn] to associate model
456    /// columns with cell renderer properties).
457    /// ## `radio`
458    /// [`true`] to make the toggle look like a radio button
459    #[doc(alias = "gtk_cell_renderer_toggle_set_radio")]
460    #[doc(alias = "radio")]
461    fn set_radio(&self, radio: bool) {
462        unsafe {
463            ffi::gtk_cell_renderer_toggle_set_radio(
464                self.as_ref().to_glib_none().0,
465                radio.into_glib(),
466            );
467        }
468    }
469
470    fn is_inconsistent(&self) -> bool {
471        ObjectExt::property(self.as_ref(), "inconsistent")
472    }
473
474    fn set_inconsistent(&self, inconsistent: bool) {
475        ObjectExt::set_property(self.as_ref(), "inconsistent", inconsistent)
476    }
477
478    #[doc(alias = "indicator-size")]
479    fn indicator_size(&self) -> i32 {
480        ObjectExt::property(self.as_ref(), "indicator-size")
481    }
482
483    #[doc(alias = "indicator-size")]
484    fn set_indicator_size(&self, indicator_size: i32) {
485        ObjectExt::set_property(self.as_ref(), "indicator-size", indicator_size)
486    }
487
488    /// The ::toggled signal is emitted when the cell is toggled.
489    ///
490    /// It is the responsibility of the application to update the model
491    /// with the correct value to store at `path`. Often this is simply the
492    /// opposite of the value currently stored at `path`.
493    /// ## `path`
494    /// string representation of [`TreePath`][crate::TreePath] describing the
495    ///  event location
496    #[doc(alias = "toggled")]
497    fn connect_toggled<F: Fn(&Self, TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
498        unsafe extern "C" fn toggled_trampoline<
499            P: IsA<CellRendererToggle>,
500            F: Fn(&P, TreePath) + 'static,
501        >(
502            this: *mut ffi::GtkCellRendererToggle,
503            path: *mut std::ffi::c_char,
504            f: glib::ffi::gpointer,
505        ) {
506            unsafe {
507                let f: &F = &*(f as *const F);
508                let path = from_glib_full(crate::ffi::gtk_tree_path_new_from_string(path));
509                f(
510                    CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref(),
511                    path,
512                )
513            }
514        }
515        unsafe {
516            let f: Box_<F> = Box_::new(f);
517            connect_raw(
518                self.as_ptr() as *mut _,
519                c"toggled".as_ptr(),
520                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
521                    toggled_trampoline::<Self, F> as *const (),
522                )),
523                Box_::into_raw(f),
524            )
525        }
526    }
527
528    #[doc(alias = "activatable")]
529    fn connect_activatable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
530        unsafe extern "C" fn notify_activatable_trampoline<
531            P: IsA<CellRendererToggle>,
532            F: Fn(&P) + 'static,
533        >(
534            this: *mut ffi::GtkCellRendererToggle,
535            _param_spec: glib::ffi::gpointer,
536            f: glib::ffi::gpointer,
537        ) {
538            unsafe {
539                let f: &F = &*(f as *const F);
540                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
541            }
542        }
543        unsafe {
544            let f: Box_<F> = Box_::new(f);
545            connect_raw(
546                self.as_ptr() as *mut _,
547                c"notify::activatable".as_ptr(),
548                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
549                    notify_activatable_trampoline::<Self, F> as *const (),
550                )),
551                Box_::into_raw(f),
552            )
553        }
554    }
555
556    #[doc(alias = "active")]
557    fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
558        unsafe extern "C" fn notify_active_trampoline<
559            P: IsA<CellRendererToggle>,
560            F: Fn(&P) + 'static,
561        >(
562            this: *mut ffi::GtkCellRendererToggle,
563            _param_spec: glib::ffi::gpointer,
564            f: glib::ffi::gpointer,
565        ) {
566            unsafe {
567                let f: &F = &*(f as *const F);
568                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
569            }
570        }
571        unsafe {
572            let f: Box_<F> = Box_::new(f);
573            connect_raw(
574                self.as_ptr() as *mut _,
575                c"notify::active".as_ptr(),
576                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
577                    notify_active_trampoline::<Self, F> as *const (),
578                )),
579                Box_::into_raw(f),
580            )
581        }
582    }
583
584    #[doc(alias = "inconsistent")]
585    fn connect_inconsistent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
586        unsafe extern "C" fn notify_inconsistent_trampoline<
587            P: IsA<CellRendererToggle>,
588            F: Fn(&P) + 'static,
589        >(
590            this: *mut ffi::GtkCellRendererToggle,
591            _param_spec: glib::ffi::gpointer,
592            f: glib::ffi::gpointer,
593        ) {
594            unsafe {
595                let f: &F = &*(f as *const F);
596                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
597            }
598        }
599        unsafe {
600            let f: Box_<F> = Box_::new(f);
601            connect_raw(
602                self.as_ptr() as *mut _,
603                c"notify::inconsistent".as_ptr(),
604                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
605                    notify_inconsistent_trampoline::<Self, F> as *const (),
606                )),
607                Box_::into_raw(f),
608            )
609        }
610    }
611
612    #[doc(alias = "indicator-size")]
613    fn connect_indicator_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
614        unsafe extern "C" fn notify_indicator_size_trampoline<
615            P: IsA<CellRendererToggle>,
616            F: Fn(&P) + 'static,
617        >(
618            this: *mut ffi::GtkCellRendererToggle,
619            _param_spec: glib::ffi::gpointer,
620            f: glib::ffi::gpointer,
621        ) {
622            unsafe {
623                let f: &F = &*(f as *const F);
624                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
625            }
626        }
627        unsafe {
628            let f: Box_<F> = Box_::new(f);
629            connect_raw(
630                self.as_ptr() as *mut _,
631                c"notify::indicator-size".as_ptr(),
632                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
633                    notify_indicator_size_trampoline::<Self, F> as *const (),
634                )),
635                Box_::into_raw(f),
636            )
637        }
638    }
639
640    #[doc(alias = "radio")]
641    fn connect_radio_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
642        unsafe extern "C" fn notify_radio_trampoline<
643            P: IsA<CellRendererToggle>,
644            F: Fn(&P) + 'static,
645        >(
646            this: *mut ffi::GtkCellRendererToggle,
647            _param_spec: glib::ffi::gpointer,
648            f: glib::ffi::gpointer,
649        ) {
650            unsafe {
651                let f: &F = &*(f as *const F);
652                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
653            }
654        }
655        unsafe {
656            let f: Box_<F> = Box_::new(f);
657            connect_raw(
658                self.as_ptr() as *mut _,
659                c"notify::radio".as_ptr(),
660                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
661                    notify_radio_trampoline::<Self, F> as *const (),
662                )),
663                Box_::into_raw(f),
664            )
665        }
666    }
667}
668
669impl<O: IsA<CellRendererToggle>> CellRendererToggleExt for O {}
gtk/auto/cell_renderer_toggle.rs

gtk/auto/
cell_renderer_toggle.rs
