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    ///
138    /// static void
139    /// text_editing_started (GtkCellRenderer *cell,
140    ///  GtkCellEditable *editable,
141    ///  const gchar *path,
142    ///  gpointer data)
143    /// {
144    ///  if (GTK_IS_ENTRY (editable))
145    ///  {
146    ///  GtkEntry *entry = GTK_ENTRY (editable);
147    ///
148    ///  // ... create a GtkEntryCompletion
149    ///
150    ///  gtk_entry_set_completion (entry, completion);
151    ///  }
152    /// }
153    /// ]|
154    ///
155    ///
156    /// </details>
157    ///
158    /// # Implements
159    ///
160    /// [`CellRendererToggleExt`][trait@crate::prelude::CellRendererToggleExt], [`CellRendererExt`][trait@crate::prelude::CellRendererExt], [`trait@glib::ObjectExt`]
161    #[doc(alias = "GtkCellRendererToggle")]
162    pub struct CellRendererToggle(Object<ffi::GtkCellRendererToggle, ffi::GtkCellRendererToggleClass>) @extends CellRenderer;
163
164    match fn {
165        type_ => || ffi::gtk_cell_renderer_toggle_get_type(),
166    }
167}
168
169impl CellRendererToggle {
170    pub const NONE: Option<&'static CellRendererToggle> = None;
171
172    /// Creates a new [`CellRendererToggle`][crate::CellRendererToggle]. Adjust rendering
173    /// parameters using object properties. Object properties can be set
174    /// globally (with [`ObjectExt::set()`][crate::glib::prelude::ObjectExt::set()]). Also, with [`TreeViewColumn`][crate::TreeViewColumn], you
175    /// can bind a property to a value in a [`TreeModel`][crate::TreeModel]. For example, you
176    /// can bind the “active” property on the cell renderer to a boolean value
177    /// in the model, thus causing the check button to reflect the state of
178    /// the model.
179    ///
180    /// # Returns
181    ///
182    /// the new cell renderer
183    #[doc(alias = "gtk_cell_renderer_toggle_new")]
184    pub fn new() -> CellRendererToggle {
185        assert_initialized_main_thread!();
186        unsafe { CellRenderer::from_glib_none(ffi::gtk_cell_renderer_toggle_new()).unsafe_cast() }
187    }
188
189    // rustdoc-stripper-ignore-next
190    /// Creates a new builder-pattern struct instance to construct [`CellRendererToggle`] objects.
191    ///
192    /// This method returns an instance of [`CellRendererToggleBuilder`](crate::builders::CellRendererToggleBuilder) which can be used to create [`CellRendererToggle`] objects.
193    pub fn builder() -> CellRendererToggleBuilder {
194        CellRendererToggleBuilder::new()
195    }
196}
197
198impl Default for CellRendererToggle {
199    fn default() -> Self {
200        Self::new()
201    }
202}
203
204// rustdoc-stripper-ignore-next
205/// A [builder-pattern] type to construct [`CellRendererToggle`] objects.
206///
207/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
208#[must_use = "The builder must be built to be used"]
209pub struct CellRendererToggleBuilder {
210    builder: glib::object::ObjectBuilder<'static, CellRendererToggle>,
211}
212
213impl CellRendererToggleBuilder {
214    fn new() -> Self {
215        Self {
216            builder: glib::object::Object::builder(),
217        }
218    }
219
220    pub fn activatable(self, activatable: bool) -> Self {
221        Self {
222            builder: self.builder.property("activatable", activatable),
223        }
224    }
225
226    pub fn active(self, active: bool) -> Self {
227        Self {
228            builder: self.builder.property("active", active),
229        }
230    }
231
232    pub fn inconsistent(self, inconsistent: bool) -> Self {
233        Self {
234            builder: self.builder.property("inconsistent", inconsistent),
235        }
236    }
237
238    pub fn indicator_size(self, indicator_size: i32) -> Self {
239        Self {
240            builder: self.builder.property("indicator-size", indicator_size),
241        }
242    }
243
244    pub fn radio(self, radio: bool) -> Self {
245        Self {
246            builder: self.builder.property("radio", radio),
247        }
248    }
249
250    pub fn cell_background(self, cell_background: impl Into<glib::GString>) -> Self {
251        Self {
252            builder: self
253                .builder
254                .property("cell-background", cell_background.into()),
255        }
256    }
257
258    /// Cell background as a [`gdk::RGBA`][crate::gdk::RGBA]
259    pub fn cell_background_rgba(self, cell_background_rgba: &gdk::RGBA) -> Self {
260        Self {
261            builder: self
262                .builder
263                .property("cell-background-rgba", cell_background_rgba),
264        }
265    }
266
267    pub fn cell_background_set(self, cell_background_set: bool) -> Self {
268        Self {
269            builder: self
270                .builder
271                .property("cell-background-set", cell_background_set),
272        }
273    }
274
275    pub fn height(self, height: i32) -> Self {
276        Self {
277            builder: self.builder.property("height", height),
278        }
279    }
280
281    pub fn is_expanded(self, is_expanded: bool) -> Self {
282        Self {
283            builder: self.builder.property("is-expanded", is_expanded),
284        }
285    }
286
287    pub fn is_expander(self, is_expander: bool) -> Self {
288        Self {
289            builder: self.builder.property("is-expander", is_expander),
290        }
291    }
292
293    pub fn mode(self, mode: CellRendererMode) -> Self {
294        Self {
295            builder: self.builder.property("mode", mode),
296        }
297    }
298
299    pub fn sensitive(self, sensitive: bool) -> Self {
300        Self {
301            builder: self.builder.property("sensitive", sensitive),
302        }
303    }
304
305    pub fn visible(self, visible: bool) -> Self {
306        Self {
307            builder: self.builder.property("visible", visible),
308        }
309    }
310
311    pub fn width(self, width: i32) -> Self {
312        Self {
313            builder: self.builder.property("width", width),
314        }
315    }
316
317    pub fn xalign(self, xalign: f32) -> Self {
318        Self {
319            builder: self.builder.property("xalign", xalign),
320        }
321    }
322
323    pub fn xpad(self, xpad: u32) -> Self {
324        Self {
325            builder: self.builder.property("xpad", xpad),
326        }
327    }
328
329    pub fn yalign(self, yalign: f32) -> Self {
330        Self {
331            builder: self.builder.property("yalign", yalign),
332        }
333    }
334
335    pub fn ypad(self, ypad: u32) -> Self {
336        Self {
337            builder: self.builder.property("ypad", ypad),
338        }
339    }
340
341    // rustdoc-stripper-ignore-next
342    /// Build the [`CellRendererToggle`].
343    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
344    pub fn build(self) -> CellRendererToggle {
345        assert_initialized_main_thread!();
346        self.builder.build()
347    }
348}
349
350/// Trait containing all [`struct@CellRendererToggle`] methods.
351///
352/// # Implementors
353///
354/// [`CellRendererToggle`][struct@crate::CellRendererToggle]
355pub trait CellRendererToggleExt: IsA<CellRendererToggle> + 'static {
356    /// Returns whether the cell renderer is activatable. See
357    /// [`set_activatable()`][Self::set_activatable()].
358    ///
359    /// # Returns
360    ///
361    /// [`true`] if the cell renderer is activatable.
362    #[doc(alias = "gtk_cell_renderer_toggle_get_activatable")]
363    #[doc(alias = "get_activatable")]
364    #[doc(alias = "activatable")]
365    fn is_activatable(&self) -> bool {
366        unsafe {
367            from_glib(ffi::gtk_cell_renderer_toggle_get_activatable(
368                self.as_ref().to_glib_none().0,
369            ))
370        }
371    }
372
373    /// Returns whether the cell renderer is active. See
374    /// [`set_active()`][Self::set_active()].
375    ///
376    /// # Returns
377    ///
378    /// [`true`] if the cell renderer is active.
379    #[doc(alias = "gtk_cell_renderer_toggle_get_active")]
380    #[doc(alias = "get_active")]
381    #[doc(alias = "active")]
382    fn is_active(&self) -> bool {
383        unsafe {
384            from_glib(ffi::gtk_cell_renderer_toggle_get_active(
385                self.as_ref().to_glib_none().0,
386            ))
387        }
388    }
389
390    /// Returns whether we’re rendering radio toggles rather than checkboxes.
391    ///
392    /// # Returns
393    ///
394    /// [`true`] if we’re rendering radio toggles rather than checkboxes
395    #[doc(alias = "gtk_cell_renderer_toggle_get_radio")]
396    #[doc(alias = "get_radio")]
397    #[doc(alias = "radio")]
398    fn is_radio(&self) -> bool {
399        unsafe {
400            from_glib(ffi::gtk_cell_renderer_toggle_get_radio(
401                self.as_ref().to_glib_none().0,
402            ))
403        }
404    }
405
406    /// Makes the cell renderer activatable.
407    /// ## `setting`
408    /// the value to set.
409    #[doc(alias = "gtk_cell_renderer_toggle_set_activatable")]
410    #[doc(alias = "activatable")]
411    fn set_activatable(&self, setting: bool) {
412        unsafe {
413            ffi::gtk_cell_renderer_toggle_set_activatable(
414                self.as_ref().to_glib_none().0,
415                setting.into_glib(),
416            );
417        }
418    }
419
420    /// Activates or deactivates a cell renderer.
421    /// ## `setting`
422    /// the value to set.
423    #[doc(alias = "gtk_cell_renderer_toggle_set_active")]
424    #[doc(alias = "active")]
425    fn set_active(&self, setting: bool) {
426        unsafe {
427            ffi::gtk_cell_renderer_toggle_set_active(
428                self.as_ref().to_glib_none().0,
429                setting.into_glib(),
430            );
431        }
432    }
433
434    /// If `radio` is [`true`], the cell renderer renders a radio toggle
435    /// (i.e. a toggle in a group of mutually-exclusive toggles).
436    /// If [`false`], it renders a check toggle (a standalone boolean option).
437    /// This can be set globally for the cell renderer, or changed just
438    /// before rendering each cell in the model (for [`TreeView`][crate::TreeView], you set
439    /// up a per-row setting using [`TreeViewColumn`][crate::TreeViewColumn] to associate model
440    /// columns with cell renderer properties).
441    /// ## `radio`
442    /// [`true`] to make the toggle look like a radio button
443    #[doc(alias = "gtk_cell_renderer_toggle_set_radio")]
444    #[doc(alias = "radio")]
445    fn set_radio(&self, radio: bool) {
446        unsafe {
447            ffi::gtk_cell_renderer_toggle_set_radio(
448                self.as_ref().to_glib_none().0,
449                radio.into_glib(),
450            );
451        }
452    }
453
454    fn is_inconsistent(&self) -> bool {
455        ObjectExt::property(self.as_ref(), "inconsistent")
456    }
457
458    fn set_inconsistent(&self, inconsistent: bool) {
459        ObjectExt::set_property(self.as_ref(), "inconsistent", inconsistent)
460    }
461
462    #[doc(alias = "indicator-size")]
463    fn indicator_size(&self) -> i32 {
464        ObjectExt::property(self.as_ref(), "indicator-size")
465    }
466
467    #[doc(alias = "indicator-size")]
468    fn set_indicator_size(&self, indicator_size: i32) {
469        ObjectExt::set_property(self.as_ref(), "indicator-size", indicator_size)
470    }
471
472    /// The ::toggled signal is emitted when the cell is toggled.
473    ///
474    /// It is the responsibility of the application to update the model
475    /// with the correct value to store at `path`. Often this is simply the
476    /// opposite of the value currently stored at `path`.
477    /// ## `path`
478    /// string representation of [`TreePath`][crate::TreePath] describing the
479    ///  event location
480    #[doc(alias = "toggled")]
481    fn connect_toggled<F: Fn(&Self, TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
482        unsafe extern "C" fn toggled_trampoline<
483            P: IsA<CellRendererToggle>,
484            F: Fn(&P, TreePath) + 'static,
485        >(
486            this: *mut ffi::GtkCellRendererToggle,
487            path: *mut std::ffi::c_char,
488            f: glib::ffi::gpointer,
489        ) {
490            unsafe {
491                let f: &F = &*(f as *const F);
492                let path = from_glib_full(crate::ffi::gtk_tree_path_new_from_string(path));
493                f(
494                    CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref(),
495                    path,
496                )
497            }
498        }
499        unsafe {
500            let f: Box_<F> = Box_::new(f);
501            connect_raw(
502                self.as_ptr() as *mut _,
503                c"toggled".as_ptr(),
504                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
505                    toggled_trampoline::<Self, F> as *const (),
506                )),
507                Box_::into_raw(f),
508            )
509        }
510    }
511
512    #[doc(alias = "activatable")]
513    fn connect_activatable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
514        unsafe extern "C" fn notify_activatable_trampoline<
515            P: IsA<CellRendererToggle>,
516            F: Fn(&P) + 'static,
517        >(
518            this: *mut ffi::GtkCellRendererToggle,
519            _param_spec: glib::ffi::gpointer,
520            f: glib::ffi::gpointer,
521        ) {
522            unsafe {
523                let f: &F = &*(f as *const F);
524                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
525            }
526        }
527        unsafe {
528            let f: Box_<F> = Box_::new(f);
529            connect_raw(
530                self.as_ptr() as *mut _,
531                c"notify::activatable".as_ptr(),
532                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
533                    notify_activatable_trampoline::<Self, F> as *const (),
534                )),
535                Box_::into_raw(f),
536            )
537        }
538    }
539
540    #[doc(alias = "active")]
541    fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
542        unsafe extern "C" fn notify_active_trampoline<
543            P: IsA<CellRendererToggle>,
544            F: Fn(&P) + 'static,
545        >(
546            this: *mut ffi::GtkCellRendererToggle,
547            _param_spec: glib::ffi::gpointer,
548            f: glib::ffi::gpointer,
549        ) {
550            unsafe {
551                let f: &F = &*(f as *const F);
552                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
553            }
554        }
555        unsafe {
556            let f: Box_<F> = Box_::new(f);
557            connect_raw(
558                self.as_ptr() as *mut _,
559                c"notify::active".as_ptr(),
560                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
561                    notify_active_trampoline::<Self, F> as *const (),
562                )),
563                Box_::into_raw(f),
564            )
565        }
566    }
567
568    #[doc(alias = "inconsistent")]
569    fn connect_inconsistent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
570        unsafe extern "C" fn notify_inconsistent_trampoline<
571            P: IsA<CellRendererToggle>,
572            F: Fn(&P) + 'static,
573        >(
574            this: *mut ffi::GtkCellRendererToggle,
575            _param_spec: glib::ffi::gpointer,
576            f: glib::ffi::gpointer,
577        ) {
578            unsafe {
579                let f: &F = &*(f as *const F);
580                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
581            }
582        }
583        unsafe {
584            let f: Box_<F> = Box_::new(f);
585            connect_raw(
586                self.as_ptr() as *mut _,
587                c"notify::inconsistent".as_ptr(),
588                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
589                    notify_inconsistent_trampoline::<Self, F> as *const (),
590                )),
591                Box_::into_raw(f),
592            )
593        }
594    }
595
596    #[doc(alias = "indicator-size")]
597    fn connect_indicator_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
598        unsafe extern "C" fn notify_indicator_size_trampoline<
599            P: IsA<CellRendererToggle>,
600            F: Fn(&P) + 'static,
601        >(
602            this: *mut ffi::GtkCellRendererToggle,
603            _param_spec: glib::ffi::gpointer,
604            f: glib::ffi::gpointer,
605        ) {
606            unsafe {
607                let f: &F = &*(f as *const F);
608                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
609            }
610        }
611        unsafe {
612            let f: Box_<F> = Box_::new(f);
613            connect_raw(
614                self.as_ptr() as *mut _,
615                c"notify::indicator-size".as_ptr(),
616                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
617                    notify_indicator_size_trampoline::<Self, F> as *const (),
618                )),
619                Box_::into_raw(f),
620            )
621        }
622    }
623
624    #[doc(alias = "radio")]
625    fn connect_radio_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
626        unsafe extern "C" fn notify_radio_trampoline<
627            P: IsA<CellRendererToggle>,
628            F: Fn(&P) + 'static,
629        >(
630            this: *mut ffi::GtkCellRendererToggle,
631            _param_spec: glib::ffi::gpointer,
632            f: glib::ffi::gpointer,
633        ) {
634            unsafe {
635                let f: &F = &*(f as *const F);
636                f(CellRendererToggle::from_glib_borrow(this).unsafe_cast_ref())
637            }
638        }
639        unsafe {
640            let f: Box_<F> = Box_::new(f);
641            connect_raw(
642                self.as_ptr() as *mut _,
643                c"notify::radio".as_ptr(),
644                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
645                    notify_radio_trampoline::<Self, F> as *const (),
646                )),
647                Box_::into_raw(f),
648            )
649        }
650    }
651}
652
653impl<O: IsA<CellRendererToggle>> CellRendererToggleExt for O {}
gtk/auto/cell_renderer_toggle.rs

gtk/auto/
cell_renderer_toggle.rs
