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

gtk/auto/
cell_renderer_toggle.rs
